Merge pull request #3450 from ipython/flatten

Flatten IPython.frontend, moving all its components to the top-level of IPython.

This includes a shim module that allows older projects to maintain backwards compatibility while warning them loudly about the change, so they can adapt to the new API.

IPython/frontend.py

@@ -0,0 +1,79 b''
+"""
+Shim to maintain backwards compatibility with old frontend imports.
+
+We have moved all contents of the old `frontend` subpackage into top-level
+subpackages (`html`, `qt` and `terminal`), and flattened the notebook into
+just `IPython.html`, formerly `IPython.frontend.html.notebook`.
+
+This will let code that was making `from IPython.frontend...` calls continue
+working, though a warning will be printed.
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2013, 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
+#-----------------------------------------------------------------------------
+from __future__ import print_function
+
+# Stdlib
+import sys
+import types
+from warnings import warn
+
+warn("The top-level `frontend` package has been deprecated. "
+     "All its subpackages have been moved to the top `IPython` level.")
+
+#-----------------------------------------------------------------------------
+# Class declarations
+#-----------------------------------------------------------------------------
+
+class ShimModule(types.ModuleType):
+    
+    def __init__(self, *args, **kwargs):
+        self._mirror = kwargs.pop("mirror")
+        super(ShimModule, self).__init__(*args, **kwargs)
+
+    def __getattr__(self, key):
+        # Use the equivalent of import_item(name), see below
+        name = "%s.%s" % (self._mirror, key)
+
+        # NOTE: the code below is copied *verbatim* from
+        # importstring.import_item. For some very strange reason that makes no
+        # sense to me, if we call it *as a function*, it doesn't work.  This
+        # has something to do with the deep bowels of the import machinery and
+        # I couldn't find a way to make the code work as a standard function
+        # call.  But at least since it's an unmodified copy of import_item,
+        # which is used extensively and has a test suite, we can be reasonably
+        # confident this is OK.  If anyone finds how to call the function, all
+        # the below could be replaced simply with:
+        #
+        # from IPython.utils.importstring import import_item
+        # return import_item('MIRROR.' + key)
+        
+        parts = name.rsplit('.', 1)
+        if len(parts) == 2:
+            # called with 'foo.bar....'
+            package, obj = parts
+            module = __import__(package, fromlist=[obj])
+            try:
+                pak = module.__dict__[obj]
+            except KeyError:
+                raise ImportError('No module named %s' % obj)
+            return pak
+        else:
+            # called with un-dotted string
+            return __import__(parts[0])
+
+
+# Unconditionally insert the shim into sys.modules so that further import calls
+# trigger the custom attribute access above
+
+sys.modules['IPython.frontend.html.notebook'] = ShimModule('notebook', mirror='IPython.html')
+sys.modules['IPython.frontend'] = ShimModule('frontend', mirror='IPython')

IPython/html/static/components

@@ -0,0 +1,1 b''
+Subproject commit 2a98f498092682f11affe9b0b86bd7e642cf7b13

IPython/utils/tests/test_importstring.py

@@ -0,0 +1,39 b''
+"""Tests for IPython.utils.importstring."""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2013  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 nose.tools as nt
+
+from IPython.utils.importstring import import_item
+
+#-----------------------------------------------------------------------------
+# Tests
+#-----------------------------------------------------------------------------
+
+def test_import_plain():
+    "Test simple imports"
+    import os
+    os2 = import_item('os')
+    nt.assert_true(os is os2)
+
+
+def test_import_nested():
+    "Test nested imports from the stdlib"
+    from os import path
+    path2 = import_item('os.path')
+    nt.assert_true(path is path2)
+
+
+def test_import_raises():
+    "Test that failing imports raise the right exception"
+    nt.assert_raises(ImportError, import_item, 'IPython.foobar')
+    

.gitignore

@@ -1,16 +1,16 b''
 MANIFEST
 build
 dist
 _build
 docs/man/*.gz
 docs/source/api/generated
 docs/gh-pages
-IPython/frontend/html/notebook/static/mathjax
+IPython/html/notebook/static/mathjax
 *.py[co]
 __pycache__
 build
 *.egg-info
 *~
 *.bak
 .ipynb_checkpoints
 .tox

.gitmodules

@@ -1,3 +1,3 b''
 [submodule "components"]
-	path = IPython/frontend/html/notebook/static/components
+	path = IPython/html/static/components
 	url = https://github.com/ipython/ipython-components.git

IPython/__init__.py

@@ -1,86 +1,86 b''
 # encoding: utf-8
 """
 IPython: tools for interactive and parallel computing in Python.
 
 http://ipython.org
 """
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2008-2011, IPython Development Team.
 #  Copyright (c) 2001-2007, Fernando Perez <[e-mail]>
 #  Copyright (c) 2001, Janko Hauser <[e-mail]>
 #  Copyright (c) 2001, Nathaniel Gray <[e-mail]>
 #
 #  Distributed under the terms of the Modified BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import absolute_import
 
 import os
 import sys
 
 #-----------------------------------------------------------------------------
 # Setup everything
 #-----------------------------------------------------------------------------
 
 # Don't forget to also update setup.py when this changes!
 if sys.version[0:3] < '2.6':
     raise ImportError('Python Version 2.6 or above is required for IPython.')
 
 # Make it easy to import extensions - they are always directly on pythonpath.
 # Therefore, non-IPython modules can be added to extensions directory.
 # This should probably be in ipapp.py.
 sys.path.append(os.path.join(os.path.dirname(__file__), "extensions"))
 
 #-----------------------------------------------------------------------------
 # Setup the top level names
 #-----------------------------------------------------------------------------
 
 from .config.loader import Config
 from .core.getipython import get_ipython
 from .core import release
 from .core.application import Application
-from .frontend.terminal.embed import embed
+from .terminal.embed import embed
 
 from .core.error import TryNext
 from .core.interactiveshell import InteractiveShell
 from .testing import test
 from .utils.sysinfo import sys_info
 from .utils.frame import extract_module_locals
 
 # Release data
 __author__ = '%s <%s>' % (release.author, release.author_email)
 __license__  = release.license
 __version__  = release.version
 version_info = release.version_info
 
 def embed_kernel(module=None, local_ns=None, **kwargs):
     """Embed and start an IPython kernel in a given scope.
     
     Parameters
     ----------
     module : ModuleType, optional
         The module to load into IPython globals (default: caller)
     local_ns : dict, optional
         The namespace to load into IPython user namespace (default: caller)
     
     kwargs : various, optional
         Further keyword args are relayed to the IPKernelApp constructor,
         allowing configuration of the Kernel.  Will only have an effect
         on the first embed_kernel call for a given process.
     
     """
     
     (caller_module, caller_locals) = extract_module_locals(1)
     if module is None:
         module = caller_module
     if local_ns is None:
         local_ns = caller_locals
     
     # Only import .zmq when we really need it
     from IPython.kernel.zmq.embed import embed_kernel as real_embed_kernel
     real_embed_kernel(module=module, local_ns=local_ns, **kwargs)

IPython/__main__.py

@@ -1,14 +1,14 b''
 # encoding: utf-8
 """Terminal-based IPython entry point.
 """
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2012, 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.
 #-----------------------------------------------------------------------------
 
-from IPython.frontend.terminal.ipapp import launch_new_instance
+from IPython.terminal.ipapp import launch_new_instance
 
 launch_new_instance()

IPython/consoleapp.py

@@ -1,391 +1,391 b''
 """ A minimal application base mixin for all ZMQ based IPython frontends.
 
 This is not a complete console app, as subprocess will not be able to receive
 input, there is no real readline support, among other limitations. This is a
-refactoring of what used to be the IPython/frontend/qt/console/qtconsoleapp.py
+refactoring of what used to be the IPython/qt/console/qtconsoleapp.py
 
 Authors:
 
 * Evan Patterson
 * Min RK
 * Erik Tollerud
 * Fernando Perez
 * Bussonnier Matthias
 * Thomas Kluyver
 * Paul Ivanov
 
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # stdlib imports
 import atexit
 import json
 import os
 import shutil
 import signal
 import sys
 import uuid
 
 
 # Local imports
 from IPython.config.application import boolean_flag
 from IPython.config.configurable import Configurable
 from IPython.core.profiledir import ProfileDir
 from IPython.kernel.blocking import BlockingKernelClient
 from IPython.kernel import KernelManager
 from IPython.kernel import tunnel_to_kernel, find_connection_file, swallow_argv
 from IPython.utils.path import filefind
 from IPython.utils.py3compat import str_to_bytes
 from IPython.utils.traitlets import (
     Dict, List, Unicode, CUnicode, Int, CBool, Any, CaselessStrEnum
 )
 from IPython.kernel.zmq.kernelapp import (
     kernel_flags,
     kernel_aliases,
     IPKernelApp
 )
 from IPython.kernel.zmq.session import Session, default_secure
 from IPython.kernel.zmq.zmqshell import ZMQInteractiveShell
 
 #-----------------------------------------------------------------------------
 # Network Constants
 #-----------------------------------------------------------------------------
 
 from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 
 flags = dict(kernel_flags)
 
 # the flags that are specific to the frontend
 # these must be scrubbed before being passed to the kernel,
 # or it will raise an error on unrecognized flags
 app_flags = {
     'existing' : ({'IPythonConsoleApp' : {'existing' : 'kernel*.json'}},
             "Connect to an existing kernel. If no argument specified, guess most recent"),
 }
 app_flags.update(boolean_flag(
     'confirm-exit', 'IPythonConsoleApp.confirm_exit',
     """Set to display confirmation dialog on exit. You can always use 'exit' or 'quit',
        to force a direct exit without any confirmation.
     """,
     """Don't prompt the user when exiting. This will terminate the kernel
        if it is owned by the frontend, and leave it alive if it is external.
     """
 ))
 flags.update(app_flags)
 
 aliases = dict(kernel_aliases)
 
 # also scrub aliases from the frontend
 app_aliases = dict(
     ip = 'KernelManager.ip',
     transport = 'KernelManager.transport',
     hb = 'IPythonConsoleApp.hb_port',
     shell = 'IPythonConsoleApp.shell_port',
     iopub = 'IPythonConsoleApp.iopub_port',
     stdin = 'IPythonConsoleApp.stdin_port',
     existing = 'IPythonConsoleApp.existing',
     f = 'IPythonConsoleApp.connection_file',
 
 
     ssh = 'IPythonConsoleApp.sshserver',
 )
 aliases.update(app_aliases)
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # IPythonConsole
 #-----------------------------------------------------------------------------
 
 classes = [IPKernelApp, ZMQInteractiveShell, KernelManager, ProfileDir, Session]
 
 try:
     from IPython.kernel.zmq.pylab.backend_inline import InlineBackend
 except ImportError:
     pass
 else:
     classes.append(InlineBackend)
 
 class IPythonConsoleApp(Configurable):
     name = 'ipython-console-mixin'
     default_config_file_name='ipython_config.py'
 
     description = """
         The IPython Mixin Console.
         
         This class contains the common portions of console client (QtConsole,
         ZMQ-based terminal console, etc).  It is not a full console, in that
         launched terminal subprocesses will not be able to accept input.
         
         The Console using this mixing supports various extra features beyond
         the single-process Terminal IPython shell, such as connecting to
         existing kernel, via:
         
             ipython <appname> --existing
         
         as well as tunnel via SSH
         
     """
 
     classes = classes
     flags = Dict(flags)
     aliases = Dict(aliases)
     kernel_manager_class = KernelManager
     kernel_client_class = BlockingKernelClient
 
     kernel_argv = List(Unicode)
     # frontend flags&aliases to be stripped when building kernel_argv
     frontend_flags = Any(app_flags)
     frontend_aliases = Any(app_aliases)
 
     # create requested profiles by default, if they don't exist:
     auto_create = CBool(True)
     # connection info:
     
     sshserver = Unicode('', config=True,
         help="""The SSH server to use to connect to the kernel.""")
     sshkey = Unicode('', config=True,
         help="""Path to the ssh key to use for logging in to the ssh server.""")
     
     hb_port = Int(0, config=True,
         help="set the heartbeat port [default: random]")
     shell_port = Int(0, config=True,
         help="set the shell (ROUTER) port [default: random]")
     iopub_port = Int(0, config=True,
         help="set the iopub (PUB) port [default: random]")
     stdin_port = Int(0, config=True,
         help="set the stdin (DEALER) port [default: random]")
     connection_file = Unicode('', config=True,
         help="""JSON file in which to store connection info [default: kernel-<pid>.json]
 
         This file will contain the IP, ports, and authentication key needed to connect
         clients to this kernel. By default, this file will be created in the security-dir
         of the current profile, but can be specified by absolute path.
         """)
     def _connection_file_default(self):
         return 'kernel-%i.json' % os.getpid()
 
     existing = CUnicode('', config=True,
         help="""Connect to an already running kernel""")
 
     confirm_exit = CBool(True, config=True,
         help="""
         Set to display confirmation dialog on exit. You can always use 'exit' or 'quit',
         to force a direct exit without any confirmation.""",
     )
 
 
     def build_kernel_argv(self, argv=None):
         """build argv to be passed to kernel subprocess"""
         if argv is None:
             argv = sys.argv[1:]
         self.kernel_argv = swallow_argv(argv, self.frontend_aliases, self.frontend_flags)
         # kernel should inherit default config file from frontend
         self.kernel_argv.append("--IPKernelApp.parent_appname='%s'" % self.name)
     
     def init_connection_file(self):
         """find the connection file, and load the info if found.
         
         The current working directory and the current profile's security
         directory will be searched for the file if it is not given by
         absolute path.
         
         When attempting to connect to an existing kernel and the `--existing`
         argument does not match an existing file, it will be interpreted as a
         fileglob, and the matching file in the current profile's security dir
         with the latest access time will be used.
         
         After this method is called, self.connection_file contains the *full path*
         to the connection file, never just its name.
         """
         if self.existing:
             try:
                 cf = find_connection_file(self.existing)
             except Exception:
                 self.log.critical("Could not find existing kernel connection file %s", self.existing)
                 self.exit(1)
             self.log.info("Connecting to existing kernel: %s" % cf)
             self.connection_file = cf
         else:
             # not existing, check if we are going to write the file
             # and ensure that self.connection_file is a full path, not just the shortname
             try:
                 cf = find_connection_file(self.connection_file)
             except Exception:
                 # file might not exist
                 if self.connection_file == os.path.basename(self.connection_file):
                     # just shortname, put it in security dir
                     cf = os.path.join(self.profile_dir.security_dir, self.connection_file)
                 else:
                     cf = self.connection_file
                 self.connection_file = cf
         
         # should load_connection_file only be used for existing?
         # as it is now, this allows reusing ports if an existing
         # file is requested
         try:
             self.load_connection_file()
         except Exception:
             self.log.error("Failed to load connection file: %r", self.connection_file, exc_info=True)
             self.exit(1)
     
     def load_connection_file(self):
         """load ip/port/hmac config from JSON connection file"""
         # this is identical to IPKernelApp.load_connection_file
         # perhaps it can be centralized somewhere?
         try:
             fname = filefind(self.connection_file, ['.', self.profile_dir.security_dir])
         except IOError:
             self.log.debug("Connection File not found: %s", self.connection_file)
             return
         self.log.debug(u"Loading connection file %s", fname)
         with open(fname) as f:
             cfg = json.load(f)
         
         self.config.KernelManager.transport = cfg.get('transport', 'tcp')
         self.config.KernelManager.ip = cfg.get('ip', LOCALHOST)
         
         for channel in ('hb', 'shell', 'iopub', 'stdin'):
             name = channel + '_port'
             if getattr(self, name) == 0 and name in cfg:
                 # not overridden by config or cl_args
                 setattr(self, name, cfg[name])
         if 'key' in cfg:
             self.config.Session.key = str_to_bytes(cfg['key'])
     
     def init_ssh(self):
         """set up ssh tunnels, if needed."""
         if not self.existing or (not self.sshserver and not self.sshkey):
             return
         
         self.load_connection_file()
         
         transport = self.config.KernelManager.transport
         ip = self.config.KernelManager.ip
         
         if transport != 'tcp':
             self.log.error("Can only use ssh tunnels with TCP sockets, not %s", transport)
             sys.exit(-1)
         
         if self.sshkey and not self.sshserver:
             # specifying just the key implies that we are connecting directly
             self.sshserver = ip
             ip = LOCALHOST
         
         # build connection dict for tunnels:
         info = dict(ip=ip,
                     shell_port=self.shell_port,
                     iopub_port=self.iopub_port,
                     stdin_port=self.stdin_port,
                     hb_port=self.hb_port
         )
         
         self.log.info("Forwarding connections to %s via %s"%(ip, self.sshserver))
         
         # tunnels return a new set of ports, which will be on localhost:
         self.config.KernelManager.ip = LOCALHOST
         try:
             newports = tunnel_to_kernel(info, self.sshserver, self.sshkey)
         except:
             # even catch KeyboardInterrupt
             self.log.error("Could not setup tunnels", exc_info=True)
             self.exit(1)
         
         self.shell_port, self.iopub_port, self.stdin_port, self.hb_port = newports
         
         cf = self.connection_file
         base,ext = os.path.splitext(cf)
         base = os.path.basename(base)
         self.connection_file = os.path.basename(base)+'-ssh'+ext
         self.log.critical("To connect another client via this tunnel, use:")
         self.log.critical("--existing %s" % self.connection_file)
     
     def _new_connection_file(self):
         cf = ''
         while not cf:
             # we don't need a 128b id to distinguish kernels, use more readable
             # 48b node segment (12 hex chars).  Users running more than 32k simultaneous
             # kernels can subclass.
             ident = str(uuid.uuid4()).split('-')[-1]
             cf = os.path.join(self.profile_dir.security_dir, 'kernel-%s.json' % ident)
             # only keep if it's actually new.  Protect against unlikely collision
             # in 48b random search space
             cf = cf if not os.path.exists(cf) else ''
         return cf
 
     def init_kernel_manager(self):
         # Don't let Qt or ZMQ swallow KeyboardInterupts.
         if self.existing:
             self.kernel_manager = None
             return
         signal.signal(signal.SIGINT, signal.SIG_DFL)
 
         # Create a KernelManager and start a kernel.
         self.kernel_manager = self.kernel_manager_class(
                                 shell_port=self.shell_port,
                                 iopub_port=self.iopub_port,
                                 stdin_port=self.stdin_port,
                                 hb_port=self.hb_port,
                                 connection_file=self.connection_file,
                                 config=self.config,
         )
         self.kernel_manager.client_factory = self.kernel_client_class
         self.kernel_manager.start_kernel(extra_arguments=self.kernel_argv)
         atexit.register(self.kernel_manager.cleanup_ipc_files)
 
         if self.sshserver:
             # ssh, write new connection file
             self.kernel_manager.write_connection_file()
 
         # in case KM defaults / ssh writing changes things:
         km = self.kernel_manager
         self.shell_port=km.shell_port
         self.iopub_port=km.iopub_port
         self.stdin_port=km.stdin_port
         self.hb_port=km.hb_port
         self.connection_file = km.connection_file
 
         atexit.register(self.kernel_manager.cleanup_connection_file)
 
     def init_kernel_client(self):
         if self.kernel_manager is not None:
             self.kernel_client = self.kernel_manager.client()
         else:
             self.kernel_client = self.kernel_client_class(
                                 shell_port=self.shell_port,
                                 iopub_port=self.iopub_port,
                                 stdin_port=self.stdin_port,
                                 hb_port=self.hb_port,
                                 connection_file=self.connection_file,
                                 config=self.config,
             )
 
         self.kernel_client.start_channels()
 
 
 
     def initialize(self, argv=None):
         """
         Classes which mix this class in should call:
                IPythonConsoleApp.initialize(self,argv)
         """
         self.init_connection_file()
         default_secure(self.config)
         self.init_ssh()
         self.init_kernel_manager()
         self.init_kernel_client()
 

IPython/core/profileapp.py

@@ -1,306 +1,306 b''
 # encoding: utf-8
 """
 An application for managing IPython profiles.
 
 To be invoked as the `ipython profile` subcommand.
 
 Authors:
 
 * Min RK
 
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  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 os
 
 from IPython.config.application import Application
 from IPython.core.application import (
     BaseIPythonApplication, base_flags
 )
 from IPython.core.profiledir import ProfileDir
 from IPython.utils.path import get_ipython_dir, get_ipython_package_dir
 from IPython.utils.traitlets import Unicode, Bool, Dict
 
 #-----------------------------------------------------------------------------
 # Constants
 #-----------------------------------------------------------------------------
 
 create_help = """Create an IPython profile by name
 
 Create an ipython profile directory by its name or
 profile directory path. Profile directories contain
 configuration, log and security related files and are named
 using the convention 'profile_<name>'. By default they are
 located in your ipython directory. Once created, you will
 can edit the configuration files in the profile
 directory to configure IPython. Most users will create a
 profile directory by name,
 `ipython profile create myprofile`, which will put the directory
 in `<ipython_dir>/profile_myprofile`.
 """
 list_help = """List available IPython profiles
 
 List all available profiles, by profile location, that can
 be found in the current working directly or in the ipython
 directory. Profile directories are named using the convention
 'profile_<profile>'.
 """
 profile_help = """Manage IPython profiles
 
 Profile directories contain
 configuration, log and security related files and are named
 using the convention 'profile_<name>'. By default they are
 located in your ipython directory.  You can create profiles
 with `ipython profile create <name>`, or see the profiles you
 already have with `ipython profile list`
 
 To get started configuring IPython, simply do:
 
 $> ipython profile create
 
 and IPython will create the default profile in <ipython_dir>/profile_default,
 where you can edit ipython_config.py to start configuring IPython.
 
 """
 
 _list_examples = "ipython profile list  # list all profiles"
 
 _create_examples = """
 ipython profile create foo         # create profile foo w/ default config files
 ipython profile create foo --reset # restage default config files over current
 ipython profile create foo --parallel # also stage parallel config files
 """
 
 _main_examples = """
 ipython profile create -h  # show the help string for the create subcommand
 ipython profile list -h    # show the help string for the list subcommand
 
 ipython locate profile foo # print the path to the directory for profile 'foo'
 """
 
 #-----------------------------------------------------------------------------
 # Profile Application Class (for `ipython profile` subcommand)
 #-----------------------------------------------------------------------------
 
 
 def list_profiles_in(path):
     """list profiles in a given root directory"""
     files = os.listdir(path)
     profiles = []
     for f in files:
         full_path = os.path.join(path, f)
         if os.path.isdir(full_path) and f.startswith('profile_'):
             profiles.append(f.split('_',1)[-1])
     return profiles
 
 
 def list_bundled_profiles():
     """list profiles that are bundled with IPython."""
     path = os.path.join(get_ipython_package_dir(), u'config', u'profile')
     files = os.listdir(path)
     profiles = []
     for profile in files:
         full_path = os.path.join(path, profile)
         if os.path.isdir(full_path) and profile != "__pycache__":
             profiles.append(profile)
     return profiles
 
 
 class ProfileLocate(BaseIPythonApplication):
     description = """print the path an IPython profile dir"""
     
     def parse_command_line(self, argv=None):
         super(ProfileLocate, self).parse_command_line(argv)
         if self.extra_args:
             self.profile = self.extra_args[0]
     
     def start(self):
         print self.profile_dir.location
 
 
 class ProfileList(Application):
     name = u'ipython-profile'
     description = list_help
     examples = _list_examples
 
     aliases = Dict({
         'ipython-dir' : 'ProfileList.ipython_dir',
         'log-level' : 'Application.log_level',
     })
     flags = Dict(dict(
         debug = ({'Application' : {'log_level' : 0}},
             "Set Application.log_level to 0, maximizing log output."
         )
     ))
 
     ipython_dir = Unicode(get_ipython_dir(), config=True,
         help="""
         The name of the IPython directory. This directory is used for logging
         configuration (through profiles), history storage, etc. The default
         is usually $HOME/.ipython. This options can also be specified through
         the environment variable IPYTHONDIR.
         """
     )
 
 
     def _print_profiles(self, profiles):
         """print list of profiles, indented."""
         for profile in profiles:
             print '    %s' % profile
 
     def list_profile_dirs(self):
         profiles = list_bundled_profiles()
         if profiles:
             print
             print "Available profiles in IPython:"
             self._print_profiles(profiles)
             print
             print "    The first request for a bundled profile will copy it"
             print "    into your IPython directory (%s)," % self.ipython_dir
             print "    where you can customize it."
         
         profiles = list_profiles_in(self.ipython_dir)
         if profiles:
             print
             print "Available profiles in %s:" % self.ipython_dir
             self._print_profiles(profiles)
         
         profiles = list_profiles_in(os.getcwdu())
         if profiles:
             print
             print "Available profiles in current directory (%s):" % os.getcwdu()
             self._print_profiles(profiles)
         
         print
         print "To use any of the above profiles, start IPython with:"
         print "    ipython --profile=<name>"
         print
 
     def start(self):
         self.list_profile_dirs()
 
 
 create_flags = {}
 create_flags.update(base_flags)
 # don't include '--init' flag, which implies running profile create in other apps
 create_flags.pop('init')
 create_flags['reset'] = ({'ProfileCreate': {'overwrite' : True}},
                         "reset config files in this profile to the defaults.")
 create_flags['parallel'] = ({'ProfileCreate': {'parallel' : True}},
                         "Include the config files for parallel "
                         "computing apps (ipengine, ipcontroller, etc.)")
 
 
 class ProfileCreate(BaseIPythonApplication):
     name = u'ipython-profile'
     description = create_help
     examples = _create_examples
     auto_create = Bool(True, config=False)
 
     def _copy_config_files_default(self):
         return True
 
     parallel = Bool(False, config=True,
         help="whether to include parallel computing config files")
     def _parallel_changed(self, name, old, new):
         parallel_files = [   'ipcontroller_config.py',
                             'ipengine_config.py',
                             'ipcluster_config.py'
                         ]
         if new:
             for cf in parallel_files:
                 self.config_files.append(cf)
         else:
             for cf in parallel_files:
                 if cf in self.config_files:
                     self.config_files.remove(cf)
 
     def parse_command_line(self, argv):
         super(ProfileCreate, self).parse_command_line(argv)
         # accept positional arg as profile name
         if self.extra_args:
             self.profile = self.extra_args[0]
 
     flags = Dict(create_flags)
 
     classes = [ProfileDir]
 
     def init_config_files(self):
         super(ProfileCreate, self).init_config_files()
         # use local imports, since these classes may import from here
-        from IPython.frontend.terminal.ipapp import TerminalIPythonApp
+        from IPython.terminal.ipapp import TerminalIPythonApp
         apps = [TerminalIPythonApp]
         try:
-            from IPython.frontend.qt.console.qtconsoleapp import IPythonQtConsoleApp
+            from IPython.qt.console.qtconsoleapp import IPythonQtConsoleApp
         except Exception:
             # this should be ImportError, but under weird circumstances
             # this might be an AttributeError, or possibly others
             # in any case, nothing should cause the profile creation to crash.
             pass
         else:
             apps.append(IPythonQtConsoleApp)
         try:
-            from IPython.frontend.html.notebook.notebookapp import NotebookApp
+            from IPython.html.notebookapp import NotebookApp
         except ImportError:
             pass
         except Exception:
             self.log.debug('Unexpected error when importing NotebookApp',
                            exc_info=True
             )
         else:
             apps.append(NotebookApp)
         if self.parallel:
             from IPython.parallel.apps.ipcontrollerapp import IPControllerApp
             from IPython.parallel.apps.ipengineapp import IPEngineApp
             from IPython.parallel.apps.ipclusterapp import IPClusterStart
             from IPython.parallel.apps.iploggerapp import IPLoggerApp
             apps.extend([
                 IPControllerApp,
                 IPEngineApp,
                 IPClusterStart,
                 IPLoggerApp,
             ])
         for App in apps:
             app = App()
             app.config.update(self.config)
             app.log = self.log
             app.overwrite = self.overwrite
             app.copy_config_files=True
             app.profile = self.profile
             app.init_profile_dir()
             app.init_config_files()
 
     def stage_default_config_file(self):
         pass
 
 
 class ProfileApp(Application):
     name = u'ipython-profile'
     description = profile_help
     examples = _main_examples
 
     subcommands = Dict(dict(
         create = (ProfileCreate, ProfileCreate.description.splitlines()[0]),
         list = (ProfileList, ProfileList.description.splitlines()[0]),
     ))
 
     def start(self):
         if self.subapp is None:
             print "No subcommand specified. Must specify one of: %s"%(self.subcommands.keys())
             print
             self.print_description()
             self.print_subcommands()
             self.exit(1)
         else:
             return self.subapp.start()
 

IPython/core/tests/test_display.py

@@ -1,38 +1,38 b''
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2010-2011 The IPython Development Team.
 #
 #  Distributed under the terms of the BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 import os
 
 import nose.tools as nt
 
 from IPython.core import display
 from IPython.utils import path as ipath
 
 def test_image_size():
     """Simple test for display.Image(args, width=x,height=y)"""
     thisurl = 'http://www.google.fr/images/srpr/logo3w.png'
     img = display.Image(url=thisurl, width=200, height=200)
     nt.assert_equal(u'<img src="%s" width="200" height="200"/>' % (thisurl), img._repr_html_())
     img = display.Image(url=thisurl, width=200)
     nt.assert_equal(u'<img src="%s" width="200"/>' % (thisurl), img._repr_html_())
     img = display.Image(url=thisurl)
     nt.assert_equal(u'<img src="%s"/>' % (thisurl), img._repr_html_())
 
 def test_image_filename_defaults():
     '''test format constraint, and validity of jpeg and png'''
     tpath = ipath.get_ipython_package_dir()
     nt.assert_raises(ValueError, display.Image, filename=os.path.join(tpath, 'testing/tests/badformat.gif'),
                      embed=True)
     nt.assert_raises(ValueError, display.Image)
     nt.assert_raises(ValueError, display.Image, data='this is not an image', format='badformat', embed=True)
-    imgfile = os.path.join(tpath, 'frontend/html/notebook/static/base/images/ipynblogo.png')
+    imgfile = os.path.join(tpath, 'html/static/base/images/ipynblogo.png')
     img = display.Image(filename=imgfile)
     nt.assert_equal('png', img.format)
     nt.assert_is_not_none(img._repr_png_())
     img = display.Image(filename=os.path.join(tpath, 'testing/tests/logo.jpg'), embed=False)
     nt.assert_equal('jpeg', img.format)
     nt.assert_is_none(img._repr_jpeg_())

IPython/html/README.md

@@ -1,73 +1,73 b''
 # IPython Notebook development
 
 ## Development dependencies
 
 Developers of the IPython Notebook will need to install the following tools:
 
 * fabric
 * node.js
 * less (`npm install -g less`)
 * bower (`npm install -g bower`)
 
 ## Components
 
 We are moving to a model where our JavaScript dependencies are managed using 
 [bower](http://bower.io/). These packages are installed in `static/components`
 and commited into our git repo. Our dependencies are described in the file
 `static/bower.json`. To update our bower packages, run `fab components` in this
 directory.
 
 Because CodeMirror does not use proper semantic versioning for its GitHub tags,
 we maintain our own fork of CodeMirror that is used with bower. This fork should
 track the upstream CodeMirror exactly; the only difference is that we are adding
 semantic versioned tags to our repo.
 
 ## less
 
 If you edit our `.less` files you will need to run the less compiler to build
 our minified css files.  This can be done by running `fab css` from this directory.
 
 ## JavaScript Documentation
 
 
 How to  Build/ view the doc  for JavaScript. JavaScript documentation  should follow a
 style close  to JSDoc  one, so you  should be  able to build  them with  your favorite
 documentation builder. Still  the documentation comment are mainly written  to be read
 with YUI  doc. You can either  build a static version,  or start a YUIdoc  server that
 will live update the doc at every page request.
 
 
 
 To do so, you will need to install YUIdoc.
 
 ### Install NodeJS
 
 Node is a browser less javascript interpreter. To install it please refer to
 the documentation for your platform. Install also NPM (node package manager) if
 it does not come bundled with it.  
 
 ### Get YUIdoc
 
 npm does by default install package in `./node_modules` instead of doing a
 system wide install. I'll leave you to yuidoc docs if you want to make a system
 wide install.
 
 First, cd into js directory :
 ```bash
-cd IPython/frontend/html/notebook/static/js/
+cd IPython/html/static/js/
 # install yuidoc
 npm install yuidocjs
 ```
 
 
 ### Run YUIdoc server
 
-From IPython/frontend/html/notebook/static/js/
+From IPython/html/static/js/
 ```bash
 # run yuidoc for install dir 
 ./node_modules/yuidocjs/lib/cli.js --server .
 ```
 
 Follow the instruction and the documentation should be available on localhost:3000
 
-Omitting `--server` will build a static version in the `out` folder by default.
  No newline at end of file
+Omitting `--server` will build a static version in the `out` folder by default.

IPython/html/notebookapp.py

@@ -1,753 +1,753 b''
 # coding: utf-8
 """A tornado based IPython notebook server.
 
 Authors:
 
 * Brian Granger
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  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
 #-----------------------------------------------------------------------------
 
 # stdlib
 import errno
 import logging
 import os
 import random
 import select
 import signal
 import socket
 import sys
 import threading
 import time
 import uuid
 import webbrowser
 
 
 # Third party
 # check for pyzmq 2.1.11
 from IPython.utils.zmqrelated import check_for_zmq
-check_for_zmq('2.1.11', 'IPython.frontend.html.notebook')
+check_for_zmq('2.1.11', 'IPython.html')
 
 import zmq
 from jinja2 import Environment, FileSystemLoader
 
 # Install the pyzmq ioloop. This has to be done before anything else from
 # tornado is imported.
 from zmq.eventloop import ioloop
 ioloop.install()
 
 # check for tornado 2.1.0
 msg = "The IPython Notebook requires tornado >= 2.1.0"
 try:
     import tornado
 except ImportError:
     raise ImportError(msg)
 try:
     version_info = tornado.version_info
 except AttributeError:
     raise ImportError(msg + ", but you have < 1.1.0")
 if version_info < (2,1,0):
     raise ImportError(msg + ", but you have %s" % tornado.version)
 
 from tornado import httpserver
 from tornado import web
 
 # Our own libraries
-from IPython.frontend.html.notebook import DEFAULT_STATIC_FILES_PATH
+from IPython.html import DEFAULT_STATIC_FILES_PATH
 
 from .services.kernels.kernelmanager import MappingKernelManager
 from .services.notebooks.nbmanager import NotebookManager
 from .services.notebooks.filenbmanager import FileNotebookManager
 from .services.clusters.clustermanager import ClusterManager
 
 from .base.handlers import AuthenticatedFileHandler, FileFindHandler
 
 from IPython.config.application import catch_config_error, boolean_flag
 from IPython.core.application import BaseIPythonApplication
-from IPython.frontend.consoleapp import IPythonConsoleApp
+from IPython.consoleapp import IPythonConsoleApp
 from IPython.kernel import swallow_argv
 from IPython.kernel.zmq.session import default_secure
 from IPython.kernel.zmq.kernelapp import (
     kernel_flags,
     kernel_aliases,
 )
 from IPython.utils.importstring import import_item
 from IPython.utils.localinterfaces import LOCALHOST
 from IPython.utils import submodule
 from IPython.utils.traitlets import (
     Dict, Unicode, Integer, List, Bool, Bytes,
     DottedObjectName
 )
 from IPython.utils import py3compat
 from IPython.utils.path import filefind
 
 from .utils import url_path_join
 
 #-----------------------------------------------------------------------------
 # Module globals
 #-----------------------------------------------------------------------------
 
 _examples = """
 ipython notebook                       # start the notebook
 ipython notebook --profile=sympy       # use the sympy profile
 ipython notebook --pylab=inline        # pylab in inline plotting mode
 ipython notebook --certfile=mycert.pem # use SSL/TLS certificate
 ipython notebook --port=5555 --ip=*    # Listen on port 5555, all interfaces
 """
 
 #-----------------------------------------------------------------------------
 # Helper functions
 #-----------------------------------------------------------------------------
 
 def random_ports(port, n):
     """Generate a list of n random ports near the given port.
 
     The first 5 ports will be sequential, and the remaining n-5 will be
     randomly selected in the range [port-2*n, port+2*n].
     """
     for i in range(min(5, n)):
         yield port + i
     for i in range(n-5):
         yield port + random.randint(-2*n, 2*n)
 
 def load_handlers(name):
     """Load the (URL pattern, handler) tuples for each component."""
-    name = 'IPython.frontend.html.notebook.' + name
+    name = 'IPython.html.' + name
     mod = __import__(name, fromlist=['default_handlers'])
     return mod.default_handlers
 
 #-----------------------------------------------------------------------------
 # The Tornado web application
 #-----------------------------------------------------------------------------
 
 class NotebookWebApplication(web.Application):
 
     def __init__(self, ipython_app, kernel_manager, notebook_manager,
                  cluster_manager, log,
                  base_project_url, settings_overrides):
 
         settings = self.init_settings(
             ipython_app, kernel_manager, notebook_manager, cluster_manager,
             log, base_project_url, settings_overrides)
         handlers = self.init_handlers(settings)
 
         super(NotebookWebApplication, self).__init__(handlers, **settings)
 
     def init_settings(self, ipython_app, kernel_manager, notebook_manager,
                       cluster_manager, log,
                       base_project_url, settings_overrides):
         # Python < 2.6.5 doesn't accept unicode keys in f(**kwargs), and
         # base_project_url will always be unicode, which will in turn
         # make the patterns unicode, and ultimately result in unicode
         # keys in kwargs to handler._execute(**kwargs) in tornado.
         # This enforces that base_project_url be ascii in that situation.
         # 
         # Note that the URLs these patterns check against are escaped,
         # and thus guaranteed to be ASCII: 'héllo' is really 'h%C3%A9llo'.
         base_project_url = py3compat.unicode_to_str(base_project_url, 'ascii')
         template_path = os.path.join(os.path.dirname(__file__), "templates")
         settings = dict(
             # basics
             base_project_url=base_project_url,
             base_kernel_url=ipython_app.base_kernel_url,
             template_path=template_path,
             static_path=ipython_app.static_file_path,
             static_handler_class = FileFindHandler,
             static_url_prefix = url_path_join(base_project_url,'/static/'),
             
             # authentication
             cookie_secret=ipython_app.cookie_secret,
             login_url=url_path_join(base_project_url,'/login'),
             read_only=ipython_app.read_only,
             password=ipython_app.password,
             
             # managers
             kernel_manager=kernel_manager,
             notebook_manager=notebook_manager,
             cluster_manager=cluster_manager,
             
             # IPython stuff
             mathjax_url=ipython_app.mathjax_url,
             max_msg_size=ipython_app.max_msg_size,
             config=ipython_app.config,
             use_less=ipython_app.use_less,
             jinja2_env=Environment(loader=FileSystemLoader(template_path)),
         )
 
         # allow custom overrides for the tornado web app.
         settings.update(settings_overrides)
         return settings
 
     def init_handlers(self, settings):
         # Load the (URL pattern, handler) tuples for each component.
         handlers = []
         handlers.extend(load_handlers('base.handlers'))
         handlers.extend(load_handlers('tree.handlers'))
         handlers.extend(load_handlers('auth.login'))
         handlers.extend(load_handlers('auth.logout'))
         handlers.extend(load_handlers('notebook.handlers'))
         handlers.extend(load_handlers('services.kernels.handlers'))
         handlers.extend(load_handlers('services.notebooks.handlers'))
         handlers.extend(load_handlers('services.clusters.handlers'))
         handlers.extend([
             (r"/files/(.*)", AuthenticatedFileHandler, {'path' : settings['notebook_manager'].notebook_dir}),
         ])
         # prepend base_project_url onto the patterns that we match
         new_handlers = []
         for handler in handlers:
             pattern = url_path_join(settings['base_project_url'], handler[0])
             new_handler = tuple([pattern] + list(handler[1:]))
             new_handlers.append(new_handler)
         return new_handlers
 
 
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 
 flags = dict(kernel_flags)
 flags['no-browser']=(
     {'NotebookApp' : {'open_browser' : False}},
     "Don't open the notebook in a browser after startup."
 )
 flags['no-mathjax']=(
     {'NotebookApp' : {'enable_mathjax' : False}},
     """Disable MathJax
     
     MathJax is the javascript library IPython uses to render math/LaTeX. It is
     very large, so you may want to disable it if you have a slow internet
     connection, or for offline use of the notebook.
     
     When disabled, equations etc. will appear as their untransformed TeX source.
     """
 )
 flags['read-only'] = (
     {'NotebookApp' : {'read_only' : True}},
     """Allow read-only access to notebooks.
     
     When using a password to protect the notebook server, this flag
     allows unauthenticated clients to view the notebook list, and
     individual notebooks, but not edit them, start kernels, or run
     code.
     
     If no password is set, the server will be entirely read-only.
     """
 )
 
 # Add notebook manager flags
 flags.update(boolean_flag('script', 'FileNotebookManager.save_script',
                'Auto-save a .py script everytime the .ipynb notebook is saved',
                'Do not auto-save .py scripts for every notebook'))
 
 # the flags that are specific to the frontend
 # these must be scrubbed before being passed to the kernel,
 # or it will raise an error on unrecognized flags
 notebook_flags = ['no-browser', 'no-mathjax', 'read-only', 'script', 'no-script']
 
 aliases = dict(kernel_aliases)
 
 aliases.update({
     'ip': 'NotebookApp.ip',
     'port': 'NotebookApp.port',
     'port-retries': 'NotebookApp.port_retries',
     'transport': 'KernelManager.transport',
     'keyfile': 'NotebookApp.keyfile',
     'certfile': 'NotebookApp.certfile',
     'notebook-dir': 'NotebookManager.notebook_dir',
     'browser': 'NotebookApp.browser',
 })
 
 # remove ipkernel flags that are singletons, and don't make sense in
 # multi-kernel evironment:
 aliases.pop('f', None)
 
 notebook_aliases = [u'port', u'port-retries', u'ip', u'keyfile', u'certfile',
                     u'notebook-dir']
 
 #-----------------------------------------------------------------------------
 # NotebookApp
 #-----------------------------------------------------------------------------
 
 class NotebookApp(BaseIPythonApplication):
 
     name = 'ipython-notebook'
     default_config_file_name='ipython_notebook_config.py'
     
     description = """
         The IPython HTML Notebook.
         
         This launches a Tornado based HTML Notebook Server that serves up an
         HTML5/Javascript Notebook client.
     """
     examples = _examples
     
     classes = IPythonConsoleApp.classes + [MappingKernelManager, NotebookManager,
         FileNotebookManager]
     flags = Dict(flags)
     aliases = Dict(aliases)
 
     kernel_argv = List(Unicode)
 
     max_msg_size = Integer(65536, config=True, help="""
         The max raw message size accepted from the browser
         over a WebSocket connection.
     """)
 
     def _log_level_default(self):
         return logging.INFO
 
     def _log_format_default(self):
         """override default log format to include time"""
         return u"%(asctime)s.%(msecs).03d [%(name)s]%(highlevel)s %(message)s"
 
     # create requested profiles by default, if they don't exist:
     auto_create = Bool(True)
 
     # file to be opened in the notebook server
     file_to_run = Unicode('')
 
     # Network related information.
 
     ip = Unicode(LOCALHOST, config=True,
         help="The IP address the notebook server will listen on."
     )
 
     def _ip_changed(self, name, old, new):
         if new == u'*': self.ip = u''
 
     port = Integer(8888, config=True,
         help="The port the notebook server will listen on."
     )
     port_retries = Integer(50, config=True,
         help="The number of additional ports to try if the specified port is not available."
     )
 
     certfile = Unicode(u'', config=True, 
         help="""The full path to an SSL/TLS certificate file."""
     )
     
     keyfile = Unicode(u'', config=True, 
         help="""The full path to a private key file for usage with SSL/TLS."""
     )
     
     cookie_secret = Bytes(b'', config=True,
         help="""The random bytes used to secure cookies.
         By default this is a new random number every time you start the Notebook.
         Set it to a value in a config file to enable logins to persist across server sessions.
         
         Note: Cookie secrets should be kept private, do not share config files with
         cookie_secret stored in plaintext (you can read the value from a file).
         """
     )
     def _cookie_secret_default(self):
         return os.urandom(1024)
 
     password = Unicode(u'', config=True,
                       help="""Hashed password to use for web authentication.
 
                       To generate, type in a python/IPython shell:
 
                         from IPython.lib import passwd; passwd()
 
                       The string should be of the form type:salt:hashed-password.
                       """
     )
 
     open_browser = Bool(True, config=True,
                         help="""Whether to open in a browser after starting.
                         The specific browser used is platform dependent and
                         determined by the python standard library `webbrowser`
                         module, unless it is overridden using the --browser
                         (NotebookApp.browser) configuration option.
                         """)
 
     browser = Unicode(u'', config=True,
                       help="""Specify what command to use to invoke a web
                       browser when opening the notebook. If not specified, the
                       default browser will be determined by the `webbrowser`
                       standard library module, which allows setting of the
                       BROWSER environment variable to override it.
                       """)
     
     read_only = Bool(False, config=True,
         help="Whether to prevent editing/execution of notebooks."
     )
 
     use_less = Bool(False, config=True,
                        help="""Wether to use Browser Side less-css parsing
                        instead of compiled css version in templates that allows
                        it. This is mainly convenient when working on the less
                        file to avoid a build step, or if user want to overwrite
                        some of the less variables without having to recompile
                        everything.
                        
                        You will need to install the less.js component in the static directory
                        either in the source tree or in your profile folder.
                        """)
 
     webapp_settings = Dict(config=True,
             help="Supply overrides for the tornado.web.Application that the "
                  "IPython notebook uses.")
     
     enable_mathjax = Bool(True, config=True,
         help="""Whether to enable MathJax for typesetting math/TeX
 
         MathJax is the javascript library IPython uses to render math/LaTeX. It is
         very large, so you may want to disable it if you have a slow internet
         connection, or for offline use of the notebook.
 
         When disabled, equations etc. will appear as their untransformed TeX source.
         """
     )
     def _enable_mathjax_changed(self, name, old, new):
         """set mathjax url to empty if mathjax is disabled"""
         if not new:
             self.mathjax_url = u''
 
     base_project_url = Unicode('/', config=True,
                                help='''The base URL for the notebook server.
 
                                Leading and trailing slashes can be omitted,
                                and will automatically be added.
                                ''')
     def _base_project_url_changed(self, name, old, new):
         if not new.startswith('/'):
             self.base_project_url = '/'+new
         elif not new.endswith('/'):
             self.base_project_url = new+'/'
 
     base_kernel_url = Unicode('/', config=True,
                                help='''The base URL for the kernel server
 
                                Leading and trailing slashes can be omitted,
                                and will automatically be added.
                                ''')
     def _base_kernel_url_changed(self, name, old, new):
         if not new.startswith('/'):
             self.base_kernel_url = '/'+new
         elif not new.endswith('/'):
             self.base_kernel_url = new+'/'
 
     websocket_url = Unicode("", config=True,
         help="""The base URL for the websocket server,
         if it differs from the HTTP server (hint: it almost certainly doesn't).
         
         Should be in the form of an HTTP origin: ws[s]://hostname[:port]
         """
     )
 
     extra_static_paths = List(Unicode, config=True,
         help="""Extra paths to search for serving static files.
         
         This allows adding javascript/css to be available from the notebook server machine,
         or overriding individual files in the IPython"""
     )
     def _extra_static_paths_default(self):
         return [os.path.join(self.profile_dir.location, 'static')]
     
     @property
     def static_file_path(self):
         """return extra paths + the default location"""
         return self.extra_static_paths + [DEFAULT_STATIC_FILES_PATH]
 
     mathjax_url = Unicode("", config=True,
         help="""The url for MathJax.js."""
     )
     def _mathjax_url_default(self):
         if not self.enable_mathjax:
             return u''
         static_url_prefix = self.webapp_settings.get("static_url_prefix",
                                                      "/static/")
         try:
             mathjax = filefind(os.path.join('mathjax', 'MathJax.js'), self.static_file_path)
         except IOError:
             if self.certfile:
                 # HTTPS: load from Rackspace CDN, because SSL certificate requires it
                 base = u"https://c328740.ssl.cf1.rackcdn.com"
             else:
                 base = u"http://cdn.mathjax.org"
             
             url = base + u"/mathjax/latest/MathJax.js"
             self.log.info("Using MathJax from CDN: %s", url)
             return url
         else:
             self.log.info("Using local MathJax from %s" % mathjax)
             return static_url_prefix+u"mathjax/MathJax.js"
     
     def _mathjax_url_changed(self, name, old, new):
         if new and not self.enable_mathjax:
             # enable_mathjax=False overrides mathjax_url
             self.mathjax_url = u''
         else:
             self.log.info("Using MathJax: %s", new)
 
-    notebook_manager_class = DottedObjectName('IPython.frontend.html.notebook.services.notebooks.filenbmanager.FileNotebookManager',
+    notebook_manager_class = DottedObjectName('IPython.html.services.notebooks.filenbmanager.FileNotebookManager',
         config=True,
         help='The notebook manager class to use.')
 
     trust_xheaders = Bool(False, config=True,
         help=("Whether to trust or not X-Scheme/X-Forwarded-Proto and X-Real-Ip/X-Forwarded-For headers"
               "sent by the upstream reverse proxy. Neccesary if the proxy handles SSL")
     )
 
     def parse_command_line(self, argv=None):
         super(NotebookApp, self).parse_command_line(argv)
         if argv is None:
             argv = sys.argv[1:]
 
         # Scrub frontend-specific flags
         self.kernel_argv = swallow_argv(argv, notebook_aliases, notebook_flags)
         # Kernel should inherit default config file from frontend
         self.kernel_argv.append("--IPKernelApp.parent_appname='%s'" % self.name)
 
         if self.extra_args:
             f = os.path.abspath(self.extra_args[0])
             if os.path.isdir(f):
                 nbdir = f
             else:
                 self.file_to_run = f
                 nbdir = os.path.dirname(f)
             self.config.NotebookManager.notebook_dir = nbdir
 
     def init_configurables(self):
         # force Session default to be secure
         default_secure(self.config)
         self.kernel_manager = MappingKernelManager(
             config=self.config, log=self.log, kernel_argv=self.kernel_argv,
             connection_dir = self.profile_dir.security_dir,
         )
         kls = import_item(self.notebook_manager_class)
         self.notebook_manager = kls(config=self.config, log=self.log)
         self.notebook_manager.load_notebook_names()
         self.cluster_manager = ClusterManager(config=self.config, log=self.log)
         self.cluster_manager.update_profiles()
 
     def init_logging(self):
         # This prevents double log messages because tornado use a root logger that
         # self.log is a child of. The logging module dipatches log messages to a log
         # and all of its ancenstors until propagate is set to False.
         self.log.propagate = False
         
         # hook up tornado 3's loggers to our app handlers
         for name in ('access', 'application', 'general'):
             logging.getLogger('tornado.%s' % name).handlers = self.log.handlers
     
     def init_webapp(self):
         """initialize tornado webapp and httpserver"""
         self.web_app = NotebookWebApplication(
             self, self.kernel_manager, self.notebook_manager, 
             self.cluster_manager, self.log,
             self.base_project_url, self.webapp_settings
         )
         if self.certfile:
             ssl_options = dict(certfile=self.certfile)
             if self.keyfile:
                 ssl_options['keyfile'] = self.keyfile
         else:
             ssl_options = None
         self.web_app.password = self.password
         self.http_server = httpserver.HTTPServer(self.web_app, ssl_options=ssl_options,
                                                  xheaders=self.trust_xheaders)
         if not self.ip:
             warning = "WARNING: The notebook server is listening on all IP addresses"
             if ssl_options is None:
                 self.log.critical(warning + " and not using encryption. This "
                     "is not recommended.")
             if not self.password and not self.read_only:
                 self.log.critical(warning + " and not using authentication. "
                     "This is highly insecure and not recommended.")
         success = None
         for port in random_ports(self.port, self.port_retries+1):
             try:
                 self.http_server.listen(port, self.ip)
             except socket.error as e:
                 # XXX: remove the e.errno == -9 block when we require
                 # tornado >= 3.0
                 if e.errno == -9 and tornado.version_info[0] < 3:
                     # The flags passed to socket.getaddrinfo from
                     # tornado.netutils.bind_sockets can cause "gaierror:
                     # [Errno -9] Address family for hostname not supported"
                     # when the interface is not associated, for example.
                     # Changing the flags to exclude socket.AI_ADDRCONFIG does
                     # not cause this error, but the only way to do this is to
                     # monkeypatch socket to remove the AI_ADDRCONFIG attribute
                     saved_AI_ADDRCONFIG = socket.AI_ADDRCONFIG
                     self.log.warn('Monkeypatching socket to fix tornado bug')
                     del(socket.AI_ADDRCONFIG)
                     try:
                         # retry the tornado call without AI_ADDRCONFIG flags
                         self.http_server.listen(port, self.ip)
                     except socket.error as e2:
                         e = e2
                     else:
                         self.port = port
                         success = True
                         break
                     # restore the monekypatch
                     socket.AI_ADDRCONFIG = saved_AI_ADDRCONFIG
                 if e.errno != errno.EADDRINUSE:
                     raise
                 self.log.info('The port %i is already in use, trying another random port.' % port)
             else:
                 self.port = port
                 success = True
                 break
         if not success:
             self.log.critical('ERROR: the notebook server could not be started because '
                               'no available port could be found.')
             self.exit(1)
     
     def init_signal(self):
         if not sys.platform.startswith('win'):
             signal.signal(signal.SIGINT, self._handle_sigint)
         signal.signal(signal.SIGTERM, self._signal_stop)
         if hasattr(signal, 'SIGUSR1'):
             # Windows doesn't support SIGUSR1
             signal.signal(signal.SIGUSR1, self._signal_info)
         if hasattr(signal, 'SIGINFO'):
             # only on BSD-based systems
             signal.signal(signal.SIGINFO, self._signal_info)
     
     def _handle_sigint(self, sig, frame):
         """SIGINT handler spawns confirmation dialog"""
         # register more forceful signal handler for ^C^C case
         signal.signal(signal.SIGINT, self._signal_stop)
         # request confirmation dialog in bg thread, to avoid
         # blocking the App
         thread = threading.Thread(target=self._confirm_exit)
         thread.daemon = True
         thread.start()
     
     def _restore_sigint_handler(self):
         """callback for restoring original SIGINT handler"""
         signal.signal(signal.SIGINT, self._handle_sigint)
     
     def _confirm_exit(self):
         """confirm shutdown on ^C
         
         A second ^C, or answering 'y' within 5s will cause shutdown,
         otherwise original SIGINT handler will be restored.
         
         This doesn't work on Windows.
         """
         # FIXME: remove this delay when pyzmq dependency is >= 2.1.11
         time.sleep(0.1)
         info = self.log.info
         info('interrupted')
         print self.notebook_info()
         sys.stdout.write("Shutdown this notebook server (y/[n])? ")
         sys.stdout.flush()
         r,w,x = select.select([sys.stdin], [], [], 5)
         if r:
             line = sys.stdin.readline()
             if line.lower().startswith('y'):
                 self.log.critical("Shutdown confirmed")
                 ioloop.IOLoop.instance().stop()
                 return
         else:
             print "No answer for 5s:",
         print "resuming operation..."
         # no answer, or answer is no:
         # set it back to original SIGINT handler
         # use IOLoop.add_callback because signal.signal must be called
         # from main thread
         ioloop.IOLoop.instance().add_callback(self._restore_sigint_handler)
     
     def _signal_stop(self, sig, frame):
         self.log.critical("received signal %s, stopping", sig)
         ioloop.IOLoop.instance().stop()
 
     def _signal_info(self, sig, frame):
         print self.notebook_info()
     
     def init_components(self):
         """Check the components submodule, and warn if it's unclean"""
         status = submodule.check_submodule_status()
         if status == 'missing':
             self.log.warn("components submodule missing, running `git submodule update`")
             submodule.update_submodules(submodule.ipython_parent())
         elif status == 'unclean':
             self.log.warn("components submodule unclean, you may see 404s on static/components")
             self.log.warn("run `setup.py submodule` or `git submodule update` to update")
             
     
     @catch_config_error
     def initialize(self, argv=None):
         self.init_logging()
         super(NotebookApp, self).initialize(argv)
         self.init_configurables()
         self.init_components()
         self.init_webapp()
         self.init_signal()
 
     def cleanup_kernels(self):
         """Shutdown all kernels.
         
         The kernels will shutdown themselves when this process no longer exists,
         but explicit shutdown allows the KernelManagers to cleanup the connection files.
         """
         self.log.info('Shutting down kernels')
         self.kernel_manager.shutdown_all()
 
     def notebook_info(self):
         "Return the current working directory and the server url information"
         mgr_info = self.notebook_manager.info_string() + "\n"
         return mgr_info +"The IPython Notebook is running at: %s" % self._url
 
     def start(self):
         """ Start the IPython Notebook server app, after initialization
         
         This method takes no arguments so all configuration and initialization
         must be done prior to calling this method."""
         ip = self.ip if self.ip else '[all ip addresses on your system]'
         proto = 'https' if self.certfile else 'http'
         info = self.log.info
         self._url = "%s://%s:%i%s" % (proto, ip, self.port,
                                       self.base_project_url)
         for line in self.notebook_info().split("\n"):
             info(line)
         info("Use Control-C to stop this server and shut down all kernels.")
 
         if self.open_browser or self.file_to_run:
             ip = self.ip or LOCALHOST
             try:
                 browser = webbrowser.get(self.browser or None)
             except webbrowser.Error as e:
                 self.log.warn('No web browser found: %s.' % e)
                 browser = None
 
             if self.file_to_run:
                 name, _ = os.path.splitext(os.path.basename(self.file_to_run))
                 url = self.notebook_manager.rev_mapping.get(name, '')
             else:
                 url = ''
             if browser:
                 b = lambda : browser.open("%s://%s:%i%s%s" % (proto, ip,
                     self.port, self.base_project_url, url), new=2)
                 threading.Thread(target=b).start()
         try:
             ioloop.IOLoop.instance().start()
         except KeyboardInterrupt:
             info("Interrupted...")
         finally:
             self.cleanup_kernels()
     
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 def launch_new_instance():
     app = NotebookApp.instance()
     app.initialize()
     app.start()
 

IPython/kernel/connect.py

@@ -1,540 +1,540 b''
 """Utilities for connecting to kernels
 
 Authors:
 
 * Min Ragan-Kelley
 
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  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
 #-----------------------------------------------------------------------------
 
 from __future__ import absolute_import
 
 import glob
 import json
 import os
 import socket
 import sys
 from getpass import getpass
 from subprocess import Popen, PIPE
 import tempfile
 
 import zmq
 
 # external imports
 from IPython.external.ssh import tunnel
 
 # IPython imports
 # from IPython.config import Configurable
 from IPython.core.profiledir import ProfileDir
 from IPython.utils.localinterfaces import LOCALHOST
 from IPython.utils.path import filefind, get_ipython_dir
 from IPython.utils.py3compat import str_to_bytes, bytes_to_str
 from IPython.utils.traitlets import (
     Bool, Integer, Unicode, CaselessStrEnum,
     HasTraits,
 )
 
 
 #-----------------------------------------------------------------------------
 # Working with Connection Files
 #-----------------------------------------------------------------------------
 
 def write_connection_file(fname=None, shell_port=0, iopub_port=0, stdin_port=0, hb_port=0,
                          control_port=0, ip=LOCALHOST, key=b'', transport='tcp'):
     """Generates a JSON config file, including the selection of random ports.
     
     Parameters
     ----------
 
     fname : unicode
         The path to the file to write
 
     shell_port : int, optional
         The port to use for ROUTER (shell) channel.
 
     iopub_port : int, optional
         The port to use for the SUB channel.
 
     stdin_port : int, optional
         The port to use for the ROUTER (raw input) channel.
 
     control_port : int, optional
         The port to use for the ROUTER (control) channel.
 
     hb_port : int, optional
         The port to use for the heartbeat REP channel.
 
     ip  : str, optional
         The ip address the kernel will bind to.
 
     key : str, optional
         The Session key used for HMAC authentication.
 
     """
     # default to temporary connector file
     if not fname:
         fname = tempfile.mktemp('.json')
     
     # Find open ports as necessary.
     
     ports = []
     ports_needed = int(shell_port <= 0) + \
                    int(iopub_port <= 0) + \
                    int(stdin_port <= 0) + \
                    int(control_port <= 0) + \
                    int(hb_port <= 0)
     if transport == 'tcp':
         for i in range(ports_needed):
             sock = socket.socket()
             sock.bind(('', 0))
             ports.append(sock)
         for i, sock in enumerate(ports):
             port = sock.getsockname()[1]
             sock.close()
             ports[i] = port
     else:
         N = 1
         for i in range(ports_needed):
             while os.path.exists("%s-%s" % (ip, str(N))):
                 N += 1
             ports.append(N)
             N += 1
     if shell_port <= 0:
         shell_port = ports.pop(0)
     if iopub_port <= 0:
         iopub_port = ports.pop(0)
     if stdin_port <= 0:
         stdin_port = ports.pop(0)
     if control_port <= 0:
         control_port = ports.pop(0)
     if hb_port <= 0:
         hb_port = ports.pop(0)
     
     cfg = dict( shell_port=shell_port,
                 iopub_port=iopub_port,
                 stdin_port=stdin_port,
                 control_port=control_port,
                 hb_port=hb_port,
               )
     cfg['ip'] = ip
     cfg['key'] = bytes_to_str(key)
     cfg['transport'] = transport
     
     with open(fname, 'w') as f:
         f.write(json.dumps(cfg, indent=2))
     
     return fname, cfg
 
 
 def get_connection_file(app=None):
     """Return the path to the connection file of an app
     
     Parameters
     ----------
     app : IPKernelApp instance [optional]
         If unspecified, the currently running app will be used
     """
     if app is None:
         from IPython.kernel.zmq.kernelapp import IPKernelApp
         if not IPKernelApp.initialized():
             raise RuntimeError("app not specified, and not in a running Kernel")
 
         app = IPKernelApp.instance()
     return filefind(app.connection_file, ['.', app.profile_dir.security_dir])
 
 
 def find_connection_file(filename, profile=None):
     """find a connection file, and return its absolute path.
     
     The current working directory and the profile's security
     directory will be searched for the file if it is not given by
     absolute path.
     
     If profile is unspecified, then the current running application's
     profile will be used, or 'default', if not run from IPython.
     
     If the argument does not match an existing file, it will be interpreted as a
     fileglob, and the matching file in the profile's security dir with
     the latest access time will be used.
     
     Parameters
     ----------
     filename : str
         The connection file or fileglob to search for.
     profile : str [optional]
         The name of the profile to use when searching for the connection file,
         if different from the current IPython session or 'default'.
     
     Returns
     -------
     str : The absolute path of the connection file.
     """
     from IPython.core.application import BaseIPythonApplication as IPApp
     try:
         # quick check for absolute path, before going through logic
         return filefind(filename)
     except IOError:
         pass
     
     if profile is None:
         # profile unspecified, check if running from an IPython app
         if IPApp.initialized():
             app = IPApp.instance()
             profile_dir = app.profile_dir
         else:
             # not running in IPython, use default profile
             profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), 'default')
     else:
         # find profiledir by profile name:
         profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile)
     security_dir = profile_dir.security_dir
     
     try:
         # first, try explicit name
         return filefind(filename, ['.', security_dir])
     except IOError:
         pass
     
     # not found by full name
     
     if '*' in filename:
         # given as a glob already
         pat = filename
     else:
         # accept any substring match
         pat = '*%s*' % filename
     matches = glob.glob( os.path.join(security_dir, pat) )
     if not matches:
         raise IOError("Could not find %r in %r" % (filename, security_dir))
     elif len(matches) == 1:
         return matches[0]
     else:
         # get most recent match, by access time:
         return sorted(matches, key=lambda f: os.stat(f).st_atime)[-1]
 
 
 def get_connection_info(connection_file=None, unpack=False, profile=None):
     """Return the connection information for the current Kernel.
     
     Parameters
     ----------
     connection_file : str [optional]
         The connection file to be used. Can be given by absolute path, or
         IPython will search in the security directory of a given profile.
         If run from IPython, 
         
         If unspecified, the connection file for the currently running
         IPython Kernel will be used, which is only allowed from inside a kernel.
     unpack : bool [default: False]
         if True, return the unpacked dict, otherwise just the string contents
         of the file.
     profile : str [optional]
         The name of the profile to use when searching for the connection file,
         if different from the current IPython session or 'default'.
         
     
     Returns
     -------
     The connection dictionary of the current kernel, as string or dict,
     depending on `unpack`.
     """
     if connection_file is None:
         # get connection file from current kernel
         cf = get_connection_file()
     else:
         # connection file specified, allow shortnames:
         cf = find_connection_file(connection_file, profile=profile)
     
     with open(cf) as f:
         info = f.read()
     
     if unpack:
         info = json.loads(info)
         # ensure key is bytes:
         info['key'] = str_to_bytes(info.get('key', ''))
     return info
 
 
 def connect_qtconsole(connection_file=None, argv=None, profile=None):
     """Connect a qtconsole to the current kernel.
     
     This is useful for connecting a second qtconsole to a kernel, or to a
     local notebook.
     
     Parameters
     ----------
     connection_file : str [optional]
         The connection file to be used. Can be given by absolute path, or
         IPython will search in the security directory of a given profile.
         If run from IPython, 
         
         If unspecified, the connection file for the currently running
         IPython Kernel will be used, which is only allowed from inside a kernel.
     argv : list [optional]
         Any extra args to be passed to the console.
     profile : str [optional]
         The name of the profile to use when searching for the connection file,
         if different from the current IPython session or 'default'.
     
     
     Returns
     -------
     subprocess.Popen instance running the qtconsole frontend
     """
     argv = [] if argv is None else argv
     
     if connection_file is None:
         # get connection file from current kernel
         cf = get_connection_file()
     else:
         cf = find_connection_file(connection_file, profile=profile)
     
     cmd = ';'.join([
-        "from IPython.frontend.qt.console import qtconsoleapp",
+        "from IPython.qt.console import qtconsoleapp",
         "qtconsoleapp.main()"
     ])
     
     return Popen([sys.executable, '-c', cmd, '--existing', cf] + argv,
         stdout=PIPE, stderr=PIPE, close_fds=True,
     )
 
 
 def tunnel_to_kernel(connection_info, sshserver, sshkey=None):
     """tunnel connections to a kernel via ssh
     
     This will open four SSH tunnels from localhost on this machine to the
     ports associated with the kernel.  They can be either direct
     localhost-localhost tunnels, or if an intermediate server is necessary,
     the kernel must be listening on a public IP.
     
     Parameters
     ----------
     connection_info : dict or str (path)
         Either a connection dict, or the path to a JSON connection file
     sshserver : str
         The ssh sever to use to tunnel to the kernel. Can be a full
         `user@server:port` string. ssh config aliases are respected.
     sshkey : str [optional]
         Path to file containing ssh key to use for authentication.
         Only necessary if your ssh config does not already associate
         a keyfile with the host.
     
     Returns
     -------
     
     (shell, iopub, stdin, hb) : ints
         The four ports on localhost that have been forwarded to the kernel.
     """
     if isinstance(connection_info, basestring):
         # it's a path, unpack it
         with open(connection_info) as f:
             connection_info = json.loads(f.read())
     
     cf = connection_info
     
     lports = tunnel.select_random_ports(4)
     rports = cf['shell_port'], cf['iopub_port'], cf['stdin_port'], cf['hb_port']
     
     remote_ip = cf['ip']
     
     if tunnel.try_passwordless_ssh(sshserver, sshkey):
         password=False
     else:
         password = getpass("SSH Password for %s: "%sshserver)
     
     for lp,rp in zip(lports, rports):
         tunnel.ssh_tunnel(lp, rp, sshserver, remote_ip, sshkey, password)
     
     return tuple(lports)
 
 
 #-----------------------------------------------------------------------------
 # Mixin for classes that work with connection files
 #-----------------------------------------------------------------------------
 
 channel_socket_types = {
     'hb' : zmq.REQ,
     'shell' : zmq.DEALER,
     'iopub' : zmq.SUB,
     'stdin' : zmq.DEALER,
     'control': zmq.DEALER,
 }
 
 port_names = [ "%s_port" % channel for channel in ('shell', 'stdin', 'iopub', 'hb', 'control')]
 
 class ConnectionFileMixin(HasTraits):
     """Mixin for configurable classes that work with connection files"""
 
     # The addresses for the communication channels
     connection_file = Unicode('')
     _connection_file_written = Bool(False)
 
     transport = CaselessStrEnum(['tcp', 'ipc'], default_value='tcp', config=True)
 
     ip = Unicode(LOCALHOST, config=True,
         help="""Set the kernel\'s IP address [default localhost].
         If the IP address is something other than localhost, then
         Consoles on other machines will be able to connect
         to the Kernel, so be careful!"""
     )
 
     def _ip_default(self):
         if self.transport == 'ipc':
             if self.connection_file:
                 return os.path.splitext(self.connection_file)[0] + '-ipc'
             else:
                 return 'kernel-ipc'
         else:
             return LOCALHOST
 
     def _ip_changed(self, name, old, new):
         if new == '*':
             self.ip = '0.0.0.0'
 
     # protected traits
 
     shell_port = Integer(0)
     iopub_port = Integer(0)
     stdin_port = Integer(0)
     control_port = Integer(0)
     hb_port = Integer(0)
 
     @property
     def ports(self):
         return [ getattr(self, name) for name in port_names ]
 
     #--------------------------------------------------------------------------
     # Connection and ipc file management
     #--------------------------------------------------------------------------
 
     def get_connection_info(self):
         """return the connection info as a dict"""
         return dict(
             transport=self.transport,
             ip=self.ip,
             shell_port=self.shell_port,
             iopub_port=self.iopub_port,
             stdin_port=self.stdin_port,
             hb_port=self.hb_port,
             control_port=self.control_port,
         )
 
     def cleanup_connection_file(self):
         """Cleanup connection file *if we wrote it*
 
         Will not raise if the connection file was already removed somehow.
         """
         if self._connection_file_written:
             # cleanup connection files on full shutdown of kernel we started
             self._connection_file_written = False
             try:
                 os.remove(self.connection_file)
             except (IOError, OSError, AttributeError):
                 pass
 
     def cleanup_ipc_files(self):
         """Cleanup ipc files if we wrote them."""
         if self.transport != 'ipc':
             return
         for port in self.ports:
             ipcfile = "%s-%i" % (self.ip, port)
             try:
                 os.remove(ipcfile)
             except (IOError, OSError):
                 pass
 
     def write_connection_file(self):
         """Write connection info to JSON dict in self.connection_file."""
         if self._connection_file_written:
             return
 
         self.connection_file, cfg = write_connection_file(self.connection_file,
             transport=self.transport, ip=self.ip, key=self.session.key,
             stdin_port=self.stdin_port, iopub_port=self.iopub_port,
             shell_port=self.shell_port, hb_port=self.hb_port,
             control_port=self.control_port,
         )
         # write_connection_file also sets default ports:
         for name in port_names:
             setattr(self, name, cfg[name])
 
         self._connection_file_written = True
 
     def load_connection_file(self):
         """Load connection info from JSON dict in self.connection_file."""
         with open(self.connection_file) as f:
             cfg = json.loads(f.read())
 
         self.transport = cfg.get('transport', 'tcp')
         self.ip = cfg['ip']
         for name in port_names:
             setattr(self, name, cfg[name])
         self.session.key = str_to_bytes(cfg['key'])
 
     #--------------------------------------------------------------------------
     # Creating connected sockets
     #--------------------------------------------------------------------------
 
     def _make_url(self, channel):
         """Make a ZeroMQ URL for a given channel."""
         transport = self.transport
         ip = self.ip
         port = getattr(self, '%s_port' % channel)
 
         if transport == 'tcp':
             return "tcp://%s:%i" % (ip, port)
         else:
             return "%s://%s-%s" % (transport, ip, port)
 
     def _create_connected_socket(self, channel, identity=None):
         """Create a zmq Socket and connect it to the kernel."""
         url = self._make_url(channel)
         socket_type = channel_socket_types[channel]
         self.log.info("Connecting to: %s" % url)
         sock = self.context.socket(socket_type)
         if identity:
             sock.identity = identity
         sock.connect(url)
         return sock
 
     def connect_iopub(self, identity=None):
         """return zmq Socket connected to the IOPub channel"""
         sock = self._create_connected_socket('iopub', identity=identity)
         sock.setsockopt(zmq.SUBSCRIBE, b'')
         return sock
 
     def connect_shell(self, identity=None):
         """return zmq Socket connected to the Shell channel"""
         return self._create_connected_socket('shell', identity=identity)
 
     def connect_stdin(self, identity=None):
         """return zmq Socket connected to the StdIn channel"""
         return self._create_connected_socket('stdin', identity=identity)
 
     def connect_hb(self, identity=None):
         """return zmq Socket connected to the Heartbeat channel"""
         return self._create_connected_socket('hb', identity=identity)
 
     def connect_control(self, identity=None):
         """return zmq Socket connected to the Heartbeat channel"""
         return self._create_connected_socket('control', identity=identity)
 
 
 __all__ = [
     'write_connection_file',
     'get_connection_file',
     'find_connection_file',
     'get_connection_info',
     'connect_qtconsole',
     'tunnel_to_kernel',
 ]

IPython/qt/console/console_widget.py

@@ -1,2009 +1,2009 b''
 """ An abstract base class for console-type widgets.
 """
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Standard library imports
 import os.path
 import re
 import sys
 from textwrap import dedent
 from unicodedata import category
 import webbrowser
 
 # System library imports
 from IPython.external.qt import QtCore, QtGui
 
 # Local imports
 from IPython.config.configurable import LoggingConfigurable
 from IPython.core.inputsplitter import ESC_SEQUENCES
-from IPython.frontend.qt.rich_text import HtmlExporter
-from IPython.frontend.qt.util import MetaQObjectHasTraits, get_font
+from IPython.qt.rich_text import HtmlExporter
+from IPython.qt.util import MetaQObjectHasTraits, get_font
 from IPython.utils.text import columnize
 from IPython.utils.traitlets import Bool, Enum, Integer, Unicode
 from ansi_code_processor import QtAnsiCodeProcessor
 from completion_widget import CompletionWidget
 from completion_html import CompletionHtml
 from completion_plain import CompletionPlain
 from kill_ring import QtKillRing
 
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 ESCAPE_CHARS = ''.join(ESC_SEQUENCES)
 ESCAPE_RE = re.compile("^["+ESCAPE_CHARS+"]+")
 
 def commonprefix(items):
     """Get common prefix for completions
 
     Return the longest common prefix of a list of strings, but with special
     treatment of escape characters that might precede commands in IPython,
     such as %magic functions. Used in tab completion.
 
     For a more general function, see os.path.commonprefix
     """
     # the last item will always have the least leading % symbol
     # min / max are first/last in alphabetical order
     first_match  = ESCAPE_RE.match(min(items))
     last_match  = ESCAPE_RE.match(max(items))
     # common suffix is (common prefix of reversed items) reversed
     if first_match and last_match:
         prefix = os.path.commonprefix((first_match.group(0)[::-1], last_match.group(0)[::-1]))[::-1]
     else:
         prefix = ''
 
     items = [s.lstrip(ESCAPE_CHARS) for s in items]
     return prefix+os.path.commonprefix(items)
 
 def is_letter_or_number(char):
     """ Returns whether the specified unicode character is a letter or a number.
     """
     cat = category(char)
     return cat.startswith('L') or cat.startswith('N')
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class ConsoleWidget(LoggingConfigurable, QtGui.QWidget):
     """ An abstract base class for console-type widgets. This class has
         functionality for:
 
             * Maintaining a prompt and editing region
             * Providing the traditional Unix-style console keyboard shortcuts
             * Performing tab completion
             * Paging text
             * Handling ANSI escape codes
 
         ConsoleWidget also provides a number of utility methods that will be
         convenient to implementors of a console-style widget.
     """
     __metaclass__ = MetaQObjectHasTraits
 
     #------ Configuration ------------------------------------------------------
 
     ansi_codes = Bool(True, config=True,
         help="Whether to process ANSI escape codes."
     )
     buffer_size = Integer(500, config=True,
         help="""
         The maximum number of lines of text before truncation. Specifying a
         non-positive number disables text truncation (not recommended).
         """
     )
     gui_completion = Enum(['plain', 'droplist', 'ncurses'], config=True,
                     default_value = 'ncurses',
                     help="""
                     The type of completer to use. Valid values are:
 
                     'plain'   : Show the availlable completion as a text list
                                 Below the editting area.
                     'droplist': Show the completion in a drop down list navigable
                                 by the arrow keys, and from which you can select
                                 completion by pressing Return.
                     'ncurses' : Show the completion as a text list which is navigable by
                                 `tab` and arrow keys.
                     """
     )
     # NOTE: this value can only be specified during initialization.
     kind = Enum(['plain', 'rich'], default_value='plain', config=True,
         help="""
         The type of underlying text widget to use. Valid values are 'plain',
         which specifies a QPlainTextEdit, and 'rich', which specifies a
         QTextEdit.
         """
     )
     # NOTE: this value can only be specified during initialization.
     paging = Enum(['inside', 'hsplit', 'vsplit', 'custom', 'none'],
                   default_value='inside', config=True,
         help="""
         The type of paging to use. Valid values are:
 
             'inside' : The widget pages like a traditional terminal.
             'hsplit' : When paging is requested, the widget is split
                        horizontally. The top pane contains the console, and the
                        bottom pane contains the paged text.
             'vsplit' : Similar to 'hsplit', except that a vertical splitter
                        used.
             'custom' : No action is taken by the widget beyond emitting a
                        'custom_page_requested(str)' signal.
             'none'   : The text is written directly to the console.
         """)
 
     font_family = Unicode(config=True,
         help="""The font family to use for the console.
         On OSX this defaults to Monaco, on Windows the default is
         Consolas with fallback of Courier, and on other platforms
         the default is Monospace.
         """)
     def _font_family_default(self):
         if sys.platform == 'win32':
             # Consolas ships with Vista/Win7, fallback to Courier if needed
             return 'Consolas'
         elif sys.platform == 'darwin':
             # OSX always has Monaco, no need for a fallback
             return 'Monaco'
         else:
             # Monospace should always exist, no need for a fallback
             return 'Monospace'
 
     font_size = Integer(config=True,
         help="""The font size. If unconfigured, Qt will be entrusted
         with the size of the font.
         """)
 
     width = Integer(81, config=True,
         help="""The width of the console at start time in number
         of characters (will double with `hsplit` paging)
         """)
 
     height = Integer(25, config=True,
         help="""The height of the console at start time in number
         of characters (will double with `vsplit` paging)
         """)
 
     # Whether to override ShortcutEvents for the keybindings defined by this
     # widget (Ctrl+n, Ctrl+a, etc). Enable this if you want this widget to take
     # priority (when it has focus) over, e.g., window-level menu shortcuts.
     override_shortcuts = Bool(False)
     
     # ------ Custom Qt Widgets -------------------------------------------------
     
     # For other projects to easily override the Qt widgets used by the console
     # (e.g. Spyder)
     custom_control = None
     custom_page_control = None
 
     #------ Signals ------------------------------------------------------------
 
     # Signals that indicate ConsoleWidget state.
     copy_available = QtCore.Signal(bool)
     redo_available = QtCore.Signal(bool)
     undo_available = QtCore.Signal(bool)
 
     # Signal emitted when paging is needed and the paging style has been
     # specified as 'custom'.
     custom_page_requested = QtCore.Signal(object)
 
     # Signal emitted when the font is changed.
     font_changed = QtCore.Signal(QtGui.QFont)
 
     #------ Protected class variables ------------------------------------------
 
     # control handles
     _control = None
     _page_control = None
     _splitter = None
 
     # When the control key is down, these keys are mapped.
     _ctrl_down_remap = { QtCore.Qt.Key_B : QtCore.Qt.Key_Left,
                          QtCore.Qt.Key_F : QtCore.Qt.Key_Right,
                          QtCore.Qt.Key_A : QtCore.Qt.Key_Home,
                          QtCore.Qt.Key_P : QtCore.Qt.Key_Up,
                          QtCore.Qt.Key_N : QtCore.Qt.Key_Down,
                          QtCore.Qt.Key_H : QtCore.Qt.Key_Backspace, }
     if not sys.platform == 'darwin':
         # On OS X, Ctrl-E already does the right thing, whereas End moves the
         # cursor to the bottom of the buffer.
         _ctrl_down_remap[QtCore.Qt.Key_E] = QtCore.Qt.Key_End
 
     # The shortcuts defined by this widget. We need to keep track of these to
     # support 'override_shortcuts' above.
     _shortcuts = set(_ctrl_down_remap.keys() +
                      [ QtCore.Qt.Key_C, QtCore.Qt.Key_G, QtCore.Qt.Key_O,
                        QtCore.Qt.Key_V ])
 
     _temp_buffer_filled = False
 
     #---------------------------------------------------------------------------
     # 'QObject' interface
     #---------------------------------------------------------------------------
 
     def __init__(self, parent=None, **kw):
         """ Create a ConsoleWidget.
 
         Parameters:
         -----------
         parent : QWidget, optional [default None]
             The parent for this widget.
         """
         QtGui.QWidget.__init__(self, parent)
         LoggingConfigurable.__init__(self, **kw)
 
         # While scrolling the pager on Mac OS X, it tears badly.  The
         # NativeGesture is platform and perhaps build-specific hence
         # we take adequate precautions here.
         self._pager_scroll_events = [QtCore.QEvent.Wheel]
         if hasattr(QtCore.QEvent, 'NativeGesture'):
             self._pager_scroll_events.append(QtCore.QEvent.NativeGesture)
 
         # Create the layout and underlying text widget.
         layout = QtGui.QStackedLayout(self)
         layout.setContentsMargins(0, 0, 0, 0)
         self._control = self._create_control()
         if self.paging in ('hsplit', 'vsplit'):
             self._splitter = QtGui.QSplitter()
             if self.paging == 'hsplit':
                 self._splitter.setOrientation(QtCore.Qt.Horizontal)
             else:
                 self._splitter.setOrientation(QtCore.Qt.Vertical)
             self._splitter.addWidget(self._control)
             layout.addWidget(self._splitter)
         else:
             layout.addWidget(self._control)
 
         # Create the paging widget, if necessary.
         if self.paging in ('inside', 'hsplit', 'vsplit'):
             self._page_control = self._create_page_control()
             if self._splitter:
                 self._page_control.hide()
                 self._splitter.addWidget(self._page_control)
             else:
                 layout.addWidget(self._page_control)
 
         # Initialize protected variables. Some variables contain useful state
         # information for subclasses; they should be considered read-only.
         self._append_before_prompt_pos = 0
         self._ansi_processor = QtAnsiCodeProcessor()
         if self.gui_completion == 'ncurses':
             self._completion_widget = CompletionHtml(self)
         elif self.gui_completion == 'droplist':
             self._completion_widget = CompletionWidget(self)
         elif self.gui_completion == 'plain':
             self._completion_widget = CompletionPlain(self)
 
         self._continuation_prompt = '> '
         self._continuation_prompt_html = None
         self._executing = False
         self._filter_resize = False
         self._html_exporter = HtmlExporter(self._control)
         self._input_buffer_executing = ''
         self._input_buffer_pending = ''
         self._kill_ring = QtKillRing(self._control)
         self._prompt = ''
         self._prompt_html = None
         self._prompt_pos = 0
         self._prompt_sep = ''
         self._reading = False
         self._reading_callback = None
         self._tab_width = 8
 
         # Set a monospaced font.
         self.reset_font()
 
         # Configure actions.
         action = QtGui.QAction('Print', None)
         action.setEnabled(True)
         printkey = QtGui.QKeySequence(QtGui.QKeySequence.Print)
         if printkey.matches("Ctrl+P") and sys.platform != 'darwin':
             # Only override the default if there is a collision.
             # Qt ctrl = cmd on OSX, so the match gets a false positive on OSX.
             printkey = "Ctrl+Shift+P"
         action.setShortcut(printkey)
         action.setShortcutContext(QtCore.Qt.WidgetWithChildrenShortcut)
         action.triggered.connect(self.print_)
         self.addAction(action)
         self.print_action = action
 
         action = QtGui.QAction('Save as HTML/XML', None)
         action.setShortcut(QtGui.QKeySequence.Save)
         action.setShortcutContext(QtCore.Qt.WidgetWithChildrenShortcut)
         action.triggered.connect(self.export_html)
         self.addAction(action)
         self.export_action = action
 
         action = QtGui.QAction('Select All', None)
         action.setEnabled(True)
         selectall = QtGui.QKeySequence(QtGui.QKeySequence.SelectAll)
         if selectall.matches("Ctrl+A") and sys.platform != 'darwin':
             # Only override the default if there is a collision.
             # Qt ctrl = cmd on OSX, so the match gets a false positive on OSX.
             selectall = "Ctrl+Shift+A"
         action.setShortcut(selectall)
         action.setShortcutContext(QtCore.Qt.WidgetWithChildrenShortcut)
         action.triggered.connect(self.select_all)
         self.addAction(action)
         self.select_all_action = action
 
         self.increase_font_size = QtGui.QAction("Bigger Font",
                 self,
                 shortcut=QtGui.QKeySequence.ZoomIn,
                 shortcutContext=QtCore.Qt.WidgetWithChildrenShortcut,
                 statusTip="Increase the font size by one point",
                 triggered=self._increase_font_size)
         self.addAction(self.increase_font_size)
 
         self.decrease_font_size = QtGui.QAction("Smaller Font",
                 self,
                 shortcut=QtGui.QKeySequence.ZoomOut,
                 shortcutContext=QtCore.Qt.WidgetWithChildrenShortcut,
                 statusTip="Decrease the font size by one point",
                 triggered=self._decrease_font_size)
         self.addAction(self.decrease_font_size)
 
         self.reset_font_size = QtGui.QAction("Normal Font",
                 self,
                 shortcut="Ctrl+0",
                 shortcutContext=QtCore.Qt.WidgetWithChildrenShortcut,
                 statusTip="Restore the Normal font size",
                 triggered=self.reset_font)
         self.addAction(self.reset_font_size)
 
         # Accept drag and drop events here. Drops were already turned off
         # in self._control when that widget was created.
         self.setAcceptDrops(True)
 
     #---------------------------------------------------------------------------
     # Drag and drop support
     #---------------------------------------------------------------------------
 
     def dragEnterEvent(self, e):
         if e.mimeData().hasUrls():
             # The link action should indicate to that the drop will insert
             # the file anme.
             e.setDropAction(QtCore.Qt.LinkAction)
             e.accept()
         elif e.mimeData().hasText():
             # By changing the action to copy we don't need to worry about
             # the user accidentally moving text around in the widget.
             e.setDropAction(QtCore.Qt.CopyAction)
             e.accept()
 
     def dragMoveEvent(self, e):
         if e.mimeData().hasUrls():
             pass
         elif e.mimeData().hasText():
             cursor = self._control.cursorForPosition(e.pos())
             if self._in_buffer(cursor.position()):
                 e.setDropAction(QtCore.Qt.CopyAction)
                 self._control.setTextCursor(cursor)
             else:
                 e.setDropAction(QtCore.Qt.IgnoreAction)
             e.accept()
 
     def dropEvent(self, e):
         if e.mimeData().hasUrls():
             self._keep_cursor_in_buffer()
             cursor = self._control.textCursor()
             filenames = [url.toLocalFile() for url in e.mimeData().urls()]
             text = ', '.join("'" + f.replace("'", "'\"'\"'") + "'"
                              for f in filenames)
             self._insert_plain_text_into_buffer(cursor, text)
         elif e.mimeData().hasText():
             cursor = self._control.cursorForPosition(e.pos())
             if self._in_buffer(cursor.position()):
                 text = e.mimeData().text()
                 self._insert_plain_text_into_buffer(cursor, text)
 
     def eventFilter(self, obj, event):
         """ Reimplemented to ensure a console-like behavior in the underlying
             text widgets.
         """
         etype = event.type()
         if etype == QtCore.QEvent.KeyPress:
 
             # Re-map keys for all filtered widgets.
             key = event.key()
             if self._control_key_down(event.modifiers()) and \
                     key in self._ctrl_down_remap:
                 new_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress,
                                             self._ctrl_down_remap[key],
                                             QtCore.Qt.NoModifier)
                 QtGui.qApp.sendEvent(obj, new_event)
                 return True
 
             elif obj == self._control:
                 return self._event_filter_console_keypress(event)
 
             elif obj == self._page_control:
                 return self._event_filter_page_keypress(event)
 
         # Make middle-click paste safe.
         elif etype == QtCore.QEvent.MouseButtonRelease and \
                 event.button() == QtCore.Qt.MidButton and \
                 obj == self._control.viewport():
             cursor = self._control.cursorForPosition(event.pos())
             self._control.setTextCursor(cursor)
             self.paste(QtGui.QClipboard.Selection)
             return True
 
         # Manually adjust the scrollbars *after* a resize event is dispatched.
         elif etype == QtCore.QEvent.Resize and not self._filter_resize:
             self._filter_resize = True
             QtGui.qApp.sendEvent(obj, event)
             self._adjust_scrollbars()
             self._filter_resize = False
             return True
 
         # Override shortcuts for all filtered widgets.
         elif etype == QtCore.QEvent.ShortcutOverride and \
                 self.override_shortcuts and \
                 self._control_key_down(event.modifiers()) and \
                 event.key() in self._shortcuts:
             event.accept()
 
         # Handle scrolling of the vsplit pager. This hack attempts to solve
         # problems with tearing of the help text inside the pager window.  This
         # happens only on Mac OS X with both PySide and PyQt. This fix isn't
         # perfect but makes the pager more usable.
         elif etype in self._pager_scroll_events and \
                 obj == self._page_control:
             self._page_control.repaint()
             return True
 
         elif etype == QtCore.QEvent.MouseMove:
             anchor = self._control.anchorAt(event.pos())
             QtGui.QToolTip.showText(event.globalPos(), anchor)
 
         return super(ConsoleWidget, self).eventFilter(obj, event)
 
     #---------------------------------------------------------------------------
     # 'QWidget' interface
     #---------------------------------------------------------------------------
 
     def sizeHint(self):
         """ Reimplemented to suggest a size that is 80 characters wide and
             25 lines high.
         """
         font_metrics = QtGui.QFontMetrics(self.font)
         margin = (self._control.frameWidth() +
                   self._control.document().documentMargin()) * 2
         style = self.style()
         splitwidth = style.pixelMetric(QtGui.QStyle.PM_SplitterWidth)
 
         # Note 1: Despite my best efforts to take the various margins into
         # account, the width is still coming out a bit too small, so we include
         # a fudge factor of one character here.
         # Note 2: QFontMetrics.maxWidth is not used here or anywhere else due
         # to a Qt bug on certain Mac OS systems where it returns 0.
         width = font_metrics.width(' ') * self.width + margin
         width += style.pixelMetric(QtGui.QStyle.PM_ScrollBarExtent)
         if self.paging == 'hsplit':
             width = width * 2 + splitwidth
 
         height = font_metrics.height() * self.height + margin
         if self.paging == 'vsplit':
             height = height * 2 + splitwidth
 
         return QtCore.QSize(width, height)
 
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' public interface
     #---------------------------------------------------------------------------
 
     def can_copy(self):
         """ Returns whether text can be copied to the clipboard.
         """
         return self._control.textCursor().hasSelection()
 
     def can_cut(self):
         """ Returns whether text can be cut to the clipboard.
         """
         cursor = self._control.textCursor()
         return (cursor.hasSelection() and
                 self._in_buffer(cursor.anchor()) and
                 self._in_buffer(cursor.position()))
 
     def can_paste(self):
         """ Returns whether text can be pasted from the clipboard.
         """
         if self._control.textInteractionFlags() & QtCore.Qt.TextEditable:
             return bool(QtGui.QApplication.clipboard().text())
         return False
 
     def clear(self, keep_input=True):
         """ Clear the console.
 
         Parameters:
         -----------
         keep_input : bool, optional (default True)
             If set, restores the old input buffer if a new prompt is written.
         """
         if self._executing:
             self._control.clear()
         else:
             if keep_input:
                 input_buffer = self.input_buffer
             self._control.clear()
             self._show_prompt()
             if keep_input:
                 self.input_buffer = input_buffer
 
     def copy(self):
         """ Copy the currently selected text to the clipboard.
         """
         self.layout().currentWidget().copy()
 
     def copy_anchor(self, anchor):
         """ Copy anchor text to the clipboard
         """
         QtGui.QApplication.clipboard().setText(anchor)
 
     def cut(self):
         """ Copy the currently selected text to the clipboard and delete it
             if it's inside the input buffer.
         """
         self.copy()
         if self.can_cut():
             self._control.textCursor().removeSelectedText()
 
     def execute(self, source=None, hidden=False, interactive=False):
         """ Executes source or the input buffer, possibly prompting for more
         input.
 
         Parameters:
         -----------
         source : str, optional
 
             The source to execute. If not specified, the input buffer will be
             used. If specified and 'hidden' is False, the input buffer will be
             replaced with the source before execution.
 
         hidden : bool, optional (default False)
 
             If set, no output will be shown and the prompt will not be modified.
             In other words, it will be completely invisible to the user that
             an execution has occurred.
 
         interactive : bool, optional (default False)
 
             Whether the console is to treat the source as having been manually
             entered by the user. The effect of this parameter depends on the
             subclass implementation.
 
         Raises:
         -------
         RuntimeError
             If incomplete input is given and 'hidden' is True. In this case,
             it is not possible to prompt for more input.
 
         Returns:
         --------
         A boolean indicating whether the source was executed.
         """
         # WARNING: The order in which things happen here is very particular, in
         # large part because our syntax highlighting is fragile. If you change
         # something, test carefully!
 
         # Decide what to execute.
         if source is None:
             source = self.input_buffer
             if not hidden:
                 # A newline is appended later, but it should be considered part
                 # of the input buffer.
                 source += '\n'
         elif not hidden:
             self.input_buffer = source
 
         # Execute the source or show a continuation prompt if it is incomplete.
         complete = self._is_complete(source, interactive)
         if hidden:
             if complete:
                 self._execute(source, hidden)
             else:
                 error = 'Incomplete noninteractive input: "%s"'
                 raise RuntimeError(error % source)
         else:
             if complete:
                 self._append_plain_text('\n')
                 self._input_buffer_executing = self.input_buffer
                 self._executing = True
                 self._prompt_finished()
 
                 # The maximum block count is only in effect during execution.
                 # This ensures that _prompt_pos does not become invalid due to
                 # text truncation.
                 self._control.document().setMaximumBlockCount(self.buffer_size)
 
                 # Setting a positive maximum block count will automatically
                 # disable the undo/redo history, but just to be safe:
                 self._control.setUndoRedoEnabled(False)
 
                 # Perform actual execution.
                 self._execute(source, hidden)
 
             else:
                 # Do this inside an edit block so continuation prompts are
                 # removed seamlessly via undo/redo.
                 cursor = self._get_end_cursor()
                 cursor.beginEditBlock()
                 cursor.insertText('\n')
                 self._insert_continuation_prompt(cursor)
                 cursor.endEditBlock()
 
                 # Do not do this inside the edit block. It works as expected
                 # when using a QPlainTextEdit control, but does not have an
                 # effect when using a QTextEdit. I believe this is a Qt bug.
                 self._control.moveCursor(QtGui.QTextCursor.End)
 
         return complete
 
     def export_html(self):
         """ Shows a dialog to export HTML/XML in various formats.
         """
         self._html_exporter.export()
 
     def _get_input_buffer(self, force=False):
         """ The text that the user has entered entered at the current prompt.
 
         If the console is currently executing, the text that is executing will
         always be returned.
         """
         # If we're executing, the input buffer may not even exist anymore due to
         # the limit imposed by 'buffer_size'. Therefore, we store it.
         if self._executing and not force:
             return self._input_buffer_executing
 
         cursor = self._get_end_cursor()
         cursor.setPosition(self._prompt_pos, QtGui.QTextCursor.KeepAnchor)
         input_buffer = cursor.selection().toPlainText()
 
         # Strip out continuation prompts.
         return input_buffer.replace('\n' + self._continuation_prompt, '\n')
 
     def _set_input_buffer(self, string):
         """ Sets the text in the input buffer.
 
         If the console is currently executing, this call has no *immediate*
         effect. When the execution is finished, the input buffer will be updated
         appropriately.
         """
         # If we're executing, store the text for later.
         if self._executing:
             self._input_buffer_pending = string
             return
 
         # Remove old text.
         cursor = self._get_end_cursor()
         cursor.beginEditBlock()
         cursor.setPosition(self._prompt_pos, QtGui.QTextCursor.KeepAnchor)
         cursor.removeSelectedText()
 
         # Insert new text with continuation prompts.
         self._insert_plain_text_into_buffer(self._get_prompt_cursor(), string)
         cursor.endEditBlock()
         self._control.moveCursor(QtGui.QTextCursor.End)
 
     input_buffer = property(_get_input_buffer, _set_input_buffer)
 
     def _get_font(self):
         """ The base font being used by the ConsoleWidget.
         """
         return self._control.document().defaultFont()
 
     def _set_font(self, font):
         """ Sets the base font for the ConsoleWidget to the specified QFont.
         """
         font_metrics = QtGui.QFontMetrics(font)
         self._control.setTabStopWidth(self.tab_width * font_metrics.width(' '))
 
         self._completion_widget.setFont(font)
         self._control.document().setDefaultFont(font)
         if self._page_control:
             self._page_control.document().setDefaultFont(font)
 
         self.font_changed.emit(font)
 
     font = property(_get_font, _set_font)
 
     def open_anchor(self, anchor):
         """ Open selected anchor in the default webbrowser
         """
         webbrowser.open( anchor )
 
     def paste(self, mode=QtGui.QClipboard.Clipboard):
         """ Paste the contents of the clipboard into the input region.
 
         Parameters:
         -----------
         mode : QClipboard::Mode, optional [default QClipboard::Clipboard]
 
             Controls which part of the system clipboard is used. This can be
             used to access the selection clipboard in X11 and the Find buffer
             in Mac OS. By default, the regular clipboard is used.
         """
         if self._control.textInteractionFlags() & QtCore.Qt.TextEditable:
             # Make sure the paste is safe.
             self._keep_cursor_in_buffer()
             cursor = self._control.textCursor()
 
             # Remove any trailing newline, which confuses the GUI and forces the
             # user to backspace.
             text = QtGui.QApplication.clipboard().text(mode).rstrip()
             self._insert_plain_text_into_buffer(cursor, dedent(text))
 
     def print_(self, printer = None):
         """ Print the contents of the ConsoleWidget to the specified QPrinter.
         """
         if (not printer):
             printer = QtGui.QPrinter()
             if(QtGui.QPrintDialog(printer).exec_() != QtGui.QDialog.Accepted):
                 return
         self._control.print_(printer)
 
     def prompt_to_top(self):
         """ Moves the prompt to the top of the viewport.
         """
         if not self._executing:
             prompt_cursor = self._get_prompt_cursor()
             if self._get_cursor().blockNumber() < prompt_cursor.blockNumber():
                 self._set_cursor(prompt_cursor)
             self._set_top_cursor(prompt_cursor)
 
     def redo(self):
         """ Redo the last operation. If there is no operation to redo, nothing
             happens.
         """
         self._control.redo()
 
     def reset_font(self):
         """ Sets the font to the default fixed-width font for this platform.
         """
         if sys.platform == 'win32':
             # Consolas ships with Vista/Win7, fallback to Courier if needed
             fallback = 'Courier'
         elif sys.platform == 'darwin':
             # OSX always has Monaco
             fallback = 'Monaco'
         else:
             # Monospace should always exist
             fallback = 'Monospace'
         font = get_font(self.font_family, fallback)
         if self.font_size:
             font.setPointSize(self.font_size)
         else:
             font.setPointSize(QtGui.qApp.font().pointSize())
         font.setStyleHint(QtGui.QFont.TypeWriter)
         self._set_font(font)
 
     def change_font_size(self, delta):
         """Change the font size by the specified amount (in points).
         """
         font = self.font
         size = max(font.pointSize() + delta, 1) # minimum 1 point
         font.setPointSize(size)
         self._set_font(font)
 
     def _increase_font_size(self):
         self.change_font_size(1)
 
     def _decrease_font_size(self):
         self.change_font_size(-1)
 
     def select_all(self):
         """ Selects all the text in the buffer.
         """
         self._control.selectAll()
 
     def _get_tab_width(self):
         """ The width (in terms of space characters) for tab characters.
         """
         return self._tab_width
 
     def _set_tab_width(self, tab_width):
         """ Sets the width (in terms of space characters) for tab characters.
         """
         font_metrics = QtGui.QFontMetrics(self.font)
         self._control.setTabStopWidth(tab_width * font_metrics.width(' '))
 
         self._tab_width = tab_width
 
     tab_width = property(_get_tab_width, _set_tab_width)
 
     def undo(self):
         """ Undo the last operation. If there is no operation to undo, nothing
             happens.
         """
         self._control.undo()
 
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' abstract interface
     #---------------------------------------------------------------------------
 
     def _is_complete(self, source, interactive):
         """ Returns whether 'source' can be executed. When triggered by an
             Enter/Return key press, 'interactive' is True; otherwise, it is
             False.
         """
         raise NotImplementedError
 
     def _execute(self, source, hidden):
         """ Execute 'source'. If 'hidden', do not show any output.
         """
         raise NotImplementedError
 
     def _prompt_started_hook(self):
         """ Called immediately after a new prompt is displayed.
         """
         pass
 
     def _prompt_finished_hook(self):
         """ Called immediately after a prompt is finished, i.e. when some input
             will be processed and a new prompt displayed.
         """
         pass
 
     def _up_pressed(self, shift_modifier):
         """ Called when the up key is pressed. Returns whether to continue
             processing the event.
         """
         return True
 
     def _down_pressed(self, shift_modifier):
         """ Called when the down key is pressed. Returns whether to continue
             processing the event.
         """
         return True
 
     def _tab_pressed(self):
         """ Called when the tab key is pressed. Returns whether to continue
             processing the event.
         """
         return False
 
     #--------------------------------------------------------------------------
     # 'ConsoleWidget' protected interface
     #--------------------------------------------------------------------------
 
     def _append_custom(self, insert, input, before_prompt=False):
         """ A low-level method for appending content to the end of the buffer.
 
         If 'before_prompt' is enabled, the content will be inserted before the
         current prompt, if there is one.
         """
         # Determine where to insert the content.
         cursor = self._control.textCursor()
         if before_prompt and (self._reading or not self._executing):
             cursor.setPosition(self._append_before_prompt_pos)
         else:
             cursor.movePosition(QtGui.QTextCursor.End)
         start_pos = cursor.position()
 
         # Perform the insertion.
         result = insert(cursor, input)
 
         # Adjust the prompt position if we have inserted before it. This is safe
         # because buffer truncation is disabled when not executing.
         if before_prompt and not self._executing:
             diff = cursor.position() - start_pos
             self._append_before_prompt_pos += diff
             self._prompt_pos += diff
 
         return result
 
     def _append_block(self, block_format=None, before_prompt=False):
         """ Appends an new QTextBlock to the end of the console buffer.
         """
         self._append_custom(self._insert_block, block_format, before_prompt)
 
     def _append_html(self, html, before_prompt=False):
         """ Appends HTML at the end of the console buffer.
         """
         self._append_custom(self._insert_html, html, before_prompt)
 
     def _append_html_fetching_plain_text(self, html, before_prompt=False):
         """ Appends HTML, then returns the plain text version of it.
         """
         return self._append_custom(self._insert_html_fetching_plain_text,
                                    html, before_prompt)
 
     def _append_plain_text(self, text, before_prompt=False):
         """ Appends plain text, processing ANSI codes if enabled.
         """
         self._append_custom(self._insert_plain_text, text, before_prompt)
 
     def _cancel_completion(self):
         """ If text completion is progress, cancel it.
         """
         self._completion_widget.cancel_completion()
 
     def _clear_temporary_buffer(self):
         """ Clears the "temporary text" buffer, i.e. all the text following
             the prompt region.
         """
         # Select and remove all text below the input buffer.
         cursor = self._get_prompt_cursor()
         prompt = self._continuation_prompt.lstrip()
         if(self._temp_buffer_filled):
             self._temp_buffer_filled = False
             while cursor.movePosition(QtGui.QTextCursor.NextBlock):
                 temp_cursor = QtGui.QTextCursor(cursor)
                 temp_cursor.select(QtGui.QTextCursor.BlockUnderCursor)
                 text = temp_cursor.selection().toPlainText().lstrip()
                 if not text.startswith(prompt):
                     break
         else:
             # We've reached the end of the input buffer and no text follows.
             return
         cursor.movePosition(QtGui.QTextCursor.Left) # Grab the newline.
         cursor.movePosition(QtGui.QTextCursor.End,
                             QtGui.QTextCursor.KeepAnchor)
         cursor.removeSelectedText()
 
         # After doing this, we have no choice but to clear the undo/redo
         # history. Otherwise, the text is not "temporary" at all, because it
         # can be recalled with undo/redo. Unfortunately, Qt does not expose
         # fine-grained control to the undo/redo system.
         if self._control.isUndoRedoEnabled():
             self._control.setUndoRedoEnabled(False)
             self._control.setUndoRedoEnabled(True)
 
     def _complete_with_items(self, cursor, items):
         """ Performs completion with 'items' at the specified cursor location.
         """
         self._cancel_completion()
 
         if len(items) == 1:
             cursor.setPosition(self._control.textCursor().position(),
                                QtGui.QTextCursor.KeepAnchor)
             cursor.insertText(items[0])
 
         elif len(items) > 1:
             current_pos = self._control.textCursor().position()
             prefix = commonprefix(items)
             if prefix:
                 cursor.setPosition(current_pos, QtGui.QTextCursor.KeepAnchor)
                 cursor.insertText(prefix)
                 current_pos = cursor.position()
 
             cursor.movePosition(QtGui.QTextCursor.Left, n=len(prefix))
             self._completion_widget.show_items(cursor, items)
 
 
     def _fill_temporary_buffer(self, cursor, text, html=False):
         """fill the area below the active editting zone with text"""
 
         current_pos = self._control.textCursor().position()
 
         cursor.beginEditBlock()
         self._append_plain_text('\n')
         self._page(text, html=html)
         cursor.endEditBlock()
 
         cursor.setPosition(current_pos)
         self._control.moveCursor(QtGui.QTextCursor.End)
         self._control.setTextCursor(cursor)
 
         self._temp_buffer_filled = True
 
 
     def _context_menu_make(self, pos):
         """ Creates a context menu for the given QPoint (in widget coordinates).
         """
         menu = QtGui.QMenu(self)
 
         self.cut_action = menu.addAction('Cut', self.cut)
         self.cut_action.setEnabled(self.can_cut())
         self.cut_action.setShortcut(QtGui.QKeySequence.Cut)
 
         self.copy_action = menu.addAction('Copy', self.copy)
         self.copy_action.setEnabled(self.can_copy())
         self.copy_action.setShortcut(QtGui.QKeySequence.Copy)
 
         self.paste_action = menu.addAction('Paste', self.paste)
         self.paste_action.setEnabled(self.can_paste())
         self.paste_action.setShortcut(QtGui.QKeySequence.Paste)
 
         anchor = self._control.anchorAt(pos)
         if anchor:
             menu.addSeparator()
             self.copy_link_action = menu.addAction(
                 'Copy Link Address', lambda: self.copy_anchor(anchor=anchor))
             self.open_link_action = menu.addAction(
                 'Open Link', lambda: self.open_anchor(anchor=anchor))
 
         menu.addSeparator()
         menu.addAction(self.select_all_action)
 
         menu.addSeparator()
         menu.addAction(self.export_action)
         menu.addAction(self.print_action)
 
         return menu
 
     def _control_key_down(self, modifiers, include_command=False):
         """ Given a KeyboardModifiers flags object, return whether the Control
         key is down.
 
         Parameters:
         -----------
         include_command : bool, optional (default True)
             Whether to treat the Command key as a (mutually exclusive) synonym
             for Control when in Mac OS.
         """
         # Note that on Mac OS, ControlModifier corresponds to the Command key
         # while MetaModifier corresponds to the Control key.
         if sys.platform == 'darwin':
             down = include_command and (modifiers & QtCore.Qt.ControlModifier)
             return bool(down) ^ bool(modifiers & QtCore.Qt.MetaModifier)
         else:
             return bool(modifiers & QtCore.Qt.ControlModifier)
 
     def _create_control(self):
         """ Creates and connects the underlying text widget.
         """
         # Create the underlying control.
         if self.custom_control:
             control = self.custom_control()
         elif self.kind == 'plain':
             control = QtGui.QPlainTextEdit()
         elif self.kind == 'rich':
             control = QtGui.QTextEdit()
             control.setAcceptRichText(False)
             control.setMouseTracking(True)
 
         # Prevent the widget from handling drops, as we already provide
         # the logic in this class.
         control.setAcceptDrops(False)
 
         # Install event filters. The filter on the viewport is needed for
         # mouse events.
         control.installEventFilter(self)
         control.viewport().installEventFilter(self)
 
         # Connect signals.
         control.customContextMenuRequested.connect(
             self._custom_context_menu_requested)
         control.copyAvailable.connect(self.copy_available)
         control.redoAvailable.connect(self.redo_available)
         control.undoAvailable.connect(self.undo_available)
 
         # Hijack the document size change signal to prevent Qt from adjusting
         # the viewport's scrollbar. We are relying on an implementation detail
         # of Q(Plain)TextEdit here, which is potentially dangerous, but without
         # this functionality we cannot create a nice terminal interface.
         layout = control.document().documentLayout()
         layout.documentSizeChanged.disconnect()
         layout.documentSizeChanged.connect(self._adjust_scrollbars)
 
         # Configure the control.
         control.setAttribute(QtCore.Qt.WA_InputMethodEnabled, True)
         control.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
         control.setReadOnly(True)
         control.setUndoRedoEnabled(False)
         control.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
         return control
 
     def _create_page_control(self):
         """ Creates and connects the underlying paging widget.
         """
         if self.custom_page_control:
             control = self.custom_page_control()
         elif self.kind == 'plain':
             control = QtGui.QPlainTextEdit()
         elif self.kind == 'rich':
             control = QtGui.QTextEdit()
         control.installEventFilter(self)
         viewport = control.viewport()
         viewport.installEventFilter(self)
         control.setReadOnly(True)
         control.setUndoRedoEnabled(False)
         control.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
         return control
 
     def _event_filter_console_keypress(self, event):
         """ Filter key events for the underlying text widget to create a
             console-like interface.
         """
         intercepted = False
         cursor = self._control.textCursor()
         position = cursor.position()
         key = event.key()
         ctrl_down = self._control_key_down(event.modifiers())
         alt_down = event.modifiers() & QtCore.Qt.AltModifier
         shift_down = event.modifiers() & QtCore.Qt.ShiftModifier
 
         #------ Special sequences ----------------------------------------------
 
         if event.matches(QtGui.QKeySequence.Copy):
             self.copy()
             intercepted = True
 
         elif event.matches(QtGui.QKeySequence.Cut):
             self.cut()
             intercepted = True
 
         elif event.matches(QtGui.QKeySequence.Paste):
             self.paste()
             intercepted = True
 
         #------ Special modifier logic -----------------------------------------
 
         elif key in (QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter):
             intercepted = True
 
             # Special handling when tab completing in text mode.
             self._cancel_completion()
 
             if self._in_buffer(position):
                 # Special handling when a reading a line of raw input.
                 if self._reading:
                     self._append_plain_text('\n')
                     self._reading = False
                     if self._reading_callback:
                         self._reading_callback()
 
                 # If the input buffer is a single line or there is only
                 # whitespace after the cursor, execute. Otherwise, split the
                 # line with a continuation prompt.
                 elif not self._executing:
                     cursor.movePosition(QtGui.QTextCursor.End,
                                         QtGui.QTextCursor.KeepAnchor)
                     at_end = len(cursor.selectedText().strip()) == 0
                     single_line = (self._get_end_cursor().blockNumber() ==
                                    self._get_prompt_cursor().blockNumber())
                     if (at_end or shift_down or single_line) and not ctrl_down:
                         self.execute(interactive = not shift_down)
                     else:
                         # Do this inside an edit block for clean undo/redo.
                         cursor.beginEditBlock()
                         cursor.setPosition(position)
                         cursor.insertText('\n')
                         self._insert_continuation_prompt(cursor)
                         cursor.endEditBlock()
 
                         # Ensure that the whole input buffer is visible.
                         # FIXME: This will not be usable if the input buffer is
                         # taller than the console widget.
                         self._control.moveCursor(QtGui.QTextCursor.End)
                         self._control.setTextCursor(cursor)
 
         #------ Control/Cmd modifier -------------------------------------------
 
         elif ctrl_down:
             if key == QtCore.Qt.Key_G:
                 self._keyboard_quit()
                 intercepted = True
 
             elif key == QtCore.Qt.Key_K:
                 if self._in_buffer(position):
                     cursor.clearSelection()
                     cursor.movePosition(QtGui.QTextCursor.EndOfLine,
                                         QtGui.QTextCursor.KeepAnchor)
                     if not cursor.hasSelection():
                         # Line deletion (remove continuation prompt)
                         cursor.movePosition(QtGui.QTextCursor.NextBlock,
                                             QtGui.QTextCursor.KeepAnchor)
                         cursor.movePosition(QtGui.QTextCursor.Right,
                                             QtGui.QTextCursor.KeepAnchor,
                                             len(self._continuation_prompt))
                     self._kill_ring.kill_cursor(cursor)
                     self._set_cursor(cursor)
                 intercepted = True
 
             elif key == QtCore.Qt.Key_L:
                 self.prompt_to_top()
                 intercepted = True
 
             elif key == QtCore.Qt.Key_O:
                 if self._page_control and self._page_control.isVisible():
                     self._page_control.setFocus()
                 intercepted = True
 
             elif key == QtCore.Qt.Key_U:
                 if self._in_buffer(position):
                     cursor.clearSelection()
                     start_line = cursor.blockNumber()
                     if start_line == self._get_prompt_cursor().blockNumber():
                         offset = len(self._prompt)
                     else:
                         offset = len(self._continuation_prompt)
                     cursor.movePosition(QtGui.QTextCursor.StartOfBlock,
                                         QtGui.QTextCursor.KeepAnchor)
                     cursor.movePosition(QtGui.QTextCursor.Right,
                                         QtGui.QTextCursor.KeepAnchor, offset)
                     self._kill_ring.kill_cursor(cursor)
                     self._set_cursor(cursor)
                 intercepted = True
 
             elif key == QtCore.Qt.Key_Y:
                 self._keep_cursor_in_buffer()
                 self._kill_ring.yank()
                 intercepted = True
 
             elif key in (QtCore.Qt.Key_Backspace, QtCore.Qt.Key_Delete):
                 if key == QtCore.Qt.Key_Backspace:
                     cursor = self._get_word_start_cursor(position)
                 else: # key == QtCore.Qt.Key_Delete
                     cursor = self._get_word_end_cursor(position)
                 cursor.setPosition(position, QtGui.QTextCursor.KeepAnchor)
                 self._kill_ring.kill_cursor(cursor)
                 intercepted = True
 
             elif key == QtCore.Qt.Key_D:
                 if len(self.input_buffer) == 0:
                     self.exit_requested.emit(self)
                 else:
                     new_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress,
                                                 QtCore.Qt.Key_Delete,
                                                 QtCore.Qt.NoModifier)
                     QtGui.qApp.sendEvent(self._control, new_event)
                     intercepted = True
 
         #------ Alt modifier ---------------------------------------------------
 
         elif alt_down:
             if key == QtCore.Qt.Key_B:
                 self._set_cursor(self._get_word_start_cursor(position))
                 intercepted = True
 
             elif key == QtCore.Qt.Key_F:
                 self._set_cursor(self._get_word_end_cursor(position))
                 intercepted = True
 
             elif key == QtCore.Qt.Key_Y:
                 self._kill_ring.rotate()
                 intercepted = True
 
             elif key == QtCore.Qt.Key_Backspace:
                 cursor = self._get_word_start_cursor(position)
                 cursor.setPosition(position, QtGui.QTextCursor.KeepAnchor)
                 self._kill_ring.kill_cursor(cursor)
                 intercepted = True
 
             elif key == QtCore.Qt.Key_D:
                 cursor = self._get_word_end_cursor(position)
                 cursor.setPosition(position, QtGui.QTextCursor.KeepAnchor)
                 self._kill_ring.kill_cursor(cursor)
                 intercepted = True
 
             elif key == QtCore.Qt.Key_Delete:
                 intercepted = True
 
             elif key == QtCore.Qt.Key_Greater:
                 self._control.moveCursor(QtGui.QTextCursor.End)
                 intercepted = True
 
             elif key == QtCore.Qt.Key_Less:
                 self._control.setTextCursor(self._get_prompt_cursor())
                 intercepted = True
 
         #------ No modifiers ---------------------------------------------------
 
         else:
             if shift_down:
                 anchormode = QtGui.QTextCursor.KeepAnchor
             else:
                 anchormode = QtGui.QTextCursor.MoveAnchor
 
             if key == QtCore.Qt.Key_Escape:
                 self._keyboard_quit()
                 intercepted = True
 
             elif key == QtCore.Qt.Key_Up:
                 if self._reading or not self._up_pressed(shift_down):
                     intercepted = True
                 else:
                     prompt_line = self._get_prompt_cursor().blockNumber()
                     intercepted = cursor.blockNumber() <= prompt_line
 
             elif key == QtCore.Qt.Key_Down:
                 if self._reading or not self._down_pressed(shift_down):
                     intercepted = True
                 else:
                     end_line = self._get_end_cursor().blockNumber()
                     intercepted = cursor.blockNumber() == end_line
 
             elif key == QtCore.Qt.Key_Tab:
                 if not self._reading:
                     if self._tab_pressed():
                         # real tab-key, insert four spaces
                         cursor.insertText(' '*4)
                     intercepted = True
 
             elif key == QtCore.Qt.Key_Left:
 
                 # Move to the previous line
                 line, col = cursor.blockNumber(), cursor.columnNumber()
                 if line > self._get_prompt_cursor().blockNumber() and \
                         col == len(self._continuation_prompt):
                     self._control.moveCursor(QtGui.QTextCursor.PreviousBlock,
                                              mode=anchormode)
                     self._control.moveCursor(QtGui.QTextCursor.EndOfBlock,
                                              mode=anchormode)
                     intercepted = True
 
                 # Regular left movement
                 else:
                     intercepted = not self._in_buffer(position - 1)
 
             elif key == QtCore.Qt.Key_Right:
                 original_block_number = cursor.blockNumber()
                 cursor.movePosition(QtGui.QTextCursor.Right,
                                 mode=anchormode)
                 if cursor.blockNumber() != original_block_number:
                     cursor.movePosition(QtGui.QTextCursor.Right,
                                         n=len(self._continuation_prompt),
                                         mode=anchormode)
                 self._set_cursor(cursor)
                 intercepted = True
 
             elif key == QtCore.Qt.Key_Home:
                 start_line = cursor.blockNumber()
                 if start_line == self._get_prompt_cursor().blockNumber():
                     start_pos = self._prompt_pos
                 else:
                     cursor.movePosition(QtGui.QTextCursor.StartOfBlock,
                                         QtGui.QTextCursor.KeepAnchor)
                     start_pos = cursor.position()
                     start_pos += len(self._continuation_prompt)
                     cursor.setPosition(position)
                 if shift_down and self._in_buffer(position):
                     cursor.setPosition(start_pos, QtGui.QTextCursor.KeepAnchor)
                 else:
                     cursor.setPosition(start_pos)
                 self._set_cursor(cursor)
                 intercepted = True
 
             elif key == QtCore.Qt.Key_Backspace:
 
                 # Line deletion (remove continuation prompt)
                 line, col = cursor.blockNumber(), cursor.columnNumber()
                 if not self._reading and \
                         col == len(self._continuation_prompt) and \
                         line > self._get_prompt_cursor().blockNumber():
                     cursor.beginEditBlock()
                     cursor.movePosition(QtGui.QTextCursor.StartOfBlock,
                                         QtGui.QTextCursor.KeepAnchor)
                     cursor.removeSelectedText()
                     cursor.deletePreviousChar()
                     cursor.endEditBlock()
                     intercepted = True
 
                 # Regular backwards deletion
                 else:
                     anchor = cursor.anchor()
                     if anchor == position:
                         intercepted = not self._in_buffer(position - 1)
                     else:
                         intercepted = not self._in_buffer(min(anchor, position))
 
             elif key == QtCore.Qt.Key_Delete:
 
                 # Line deletion (remove continuation prompt)
                 if not self._reading and self._in_buffer(position) and \
                         cursor.atBlockEnd() and not cursor.hasSelection():
                     cursor.movePosition(QtGui.QTextCursor.NextBlock,
                                         QtGui.QTextCursor.KeepAnchor)
                     cursor.movePosition(QtGui.QTextCursor.Right,
                                         QtGui.QTextCursor.KeepAnchor,
                                         len(self._continuation_prompt))
                     cursor.removeSelectedText()
                     intercepted = True
 
                 # Regular forwards deletion:
                 else:
                     anchor = cursor.anchor()
                     intercepted = (not self._in_buffer(anchor) or
                                    not self._in_buffer(position))
 
         # Don't move the cursor if Control/Cmd is pressed to allow copy-paste
         # using the keyboard in any part of the buffer. Also, permit scrolling
         # with Page Up/Down keys. Finally, if we're executing, don't move the
         # cursor (if even this made sense, we can't guarantee that the prompt
         # position is still valid due to text truncation).
         if not (self._control_key_down(event.modifiers(), include_command=True)
                 or key in (QtCore.Qt.Key_PageUp, QtCore.Qt.Key_PageDown)
                 or (self._executing and not self._reading)):
             self._keep_cursor_in_buffer()
 
         return intercepted
 
     def _event_filter_page_keypress(self, event):
         """ Filter key events for the paging widget to create console-like
             interface.
         """
         key = event.key()
         ctrl_down = self._control_key_down(event.modifiers())
         alt_down = event.modifiers() & QtCore.Qt.AltModifier
 
         if ctrl_down:
             if key == QtCore.Qt.Key_O:
                 self._control.setFocus()
                 intercept = True
 
         elif alt_down:
             if key == QtCore.Qt.Key_Greater:
                 self._page_control.moveCursor(QtGui.QTextCursor.End)
                 intercepted = True
 
             elif key == QtCore.Qt.Key_Less:
                 self._page_control.moveCursor(QtGui.QTextCursor.Start)
                 intercepted = True
 
         elif key in (QtCore.Qt.Key_Q, QtCore.Qt.Key_Escape):
             if self._splitter:
                 self._page_control.hide()
                 self._control.setFocus()
             else:
                 self.layout().setCurrentWidget(self._control)
             return True
 
         elif key in (QtCore.Qt.Key_Enter, QtCore.Qt.Key_Return,
                      QtCore.Qt.Key_Tab):
             new_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress,
                                         QtCore.Qt.Key_PageDown,
                                         QtCore.Qt.NoModifier)
             QtGui.qApp.sendEvent(self._page_control, new_event)
             return True
 
         elif key == QtCore.Qt.Key_Backspace:
             new_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress,
                                         QtCore.Qt.Key_PageUp,
                                         QtCore.Qt.NoModifier)
             QtGui.qApp.sendEvent(self._page_control, new_event)
             return True
 
         return False
 
     def _format_as_columns(self, items, separator='  '):
         """ Transform a list of strings into a single string with columns.
 
         Parameters
         ----------
         items : sequence of strings
             The strings to process.
 
         separator : str, optional [default is two spaces]
             The string that separates columns.
 
         Returns
         -------
         The formatted string.
         """
         # Calculate the number of characters available.
         width = self._control.viewport().width()
         char_width = QtGui.QFontMetrics(self.font).width(' ')
         displaywidth = max(10, (width / char_width) - 1)
 
         return columnize(items, separator, displaywidth)
 
     def _get_block_plain_text(self, block):
         """ Given a QTextBlock, return its unformatted text.
         """
         cursor = QtGui.QTextCursor(block)
         cursor.movePosition(QtGui.QTextCursor.StartOfBlock)
         cursor.movePosition(QtGui.QTextCursor.EndOfBlock,
                             QtGui.QTextCursor.KeepAnchor)
         return cursor.selection().toPlainText()
 
     def _get_cursor(self):
         """ Convenience method that returns a cursor for the current position.
         """
         return self._control.textCursor()
 
     def _get_end_cursor(self):
         """ Convenience method that returns a cursor for the last character.
         """
         cursor = self._control.textCursor()
         cursor.movePosition(QtGui.QTextCursor.End)
         return cursor
 
     def _get_input_buffer_cursor_column(self):
         """ Returns the column of the cursor in the input buffer, excluding the
             contribution by the prompt, or -1 if there is no such column.
         """
         prompt = self._get_input_buffer_cursor_prompt()
         if prompt is None:
             return -1
         else:
             cursor = self._control.textCursor()
             return cursor.columnNumber() - len(prompt)
 
     def _get_input_buffer_cursor_line(self):
         """ Returns the text of the line of the input buffer that contains the
             cursor, or None if there is no such line.
         """
         prompt = self._get_input_buffer_cursor_prompt()
         if prompt is None:
             return None
         else:
             cursor = self._control.textCursor()
             text = self._get_block_plain_text(cursor.block())
             return text[len(prompt):]
 
     def _get_input_buffer_cursor_prompt(self):
         """ Returns the (plain text) prompt for line of the input buffer that
             contains the cursor, or None if there is no such line.
         """
         if self._executing:
             return None
         cursor = self._control.textCursor()
         if cursor.position() >= self._prompt_pos:
             if cursor.blockNumber() == self._get_prompt_cursor().blockNumber():
                 return self._prompt
             else:
                 return self._continuation_prompt
         else:
             return None
 
     def _get_prompt_cursor(self):
         """ Convenience method that returns a cursor for the prompt position.
         """
         cursor = self._control.textCursor()
         cursor.setPosition(self._prompt_pos)
         return cursor
 
     def _get_selection_cursor(self, start, end):
         """ Convenience method that returns a cursor with text selected between
             the positions 'start' and 'end'.
         """
         cursor = self._control.textCursor()
         cursor.setPosition(start)
         cursor.setPosition(end, QtGui.QTextCursor.KeepAnchor)
         return cursor
 
     def _get_word_start_cursor(self, position):
         """ Find the start of the word to the left the given position. If a
             sequence of non-word characters precedes the first word, skip over
             them. (This emulates the behavior of bash, emacs, etc.)
         """
         document = self._control.document()
         position -= 1
         while position >= self._prompt_pos and \
                   not is_letter_or_number(document.characterAt(position)):
             position -= 1
         while position >= self._prompt_pos and \
                   is_letter_or_number(document.characterAt(position)):
             position -= 1
         cursor = self._control.textCursor()
         cursor.setPosition(position + 1)
         return cursor
 
     def _get_word_end_cursor(self, position):
         """ Find the end of the word to the right the given position. If a
             sequence of non-word characters precedes the first word, skip over
             them. (This emulates the behavior of bash, emacs, etc.)
         """
         document = self._control.document()
         end = self._get_end_cursor().position()
         while position < end and \
                   not is_letter_or_number(document.characterAt(position)):
             position += 1
         while position < end and \
                   is_letter_or_number(document.characterAt(position)):
             position += 1
         cursor = self._control.textCursor()
         cursor.setPosition(position)
         return cursor
 
     def _insert_continuation_prompt(self, cursor):
         """ Inserts new continuation prompt using the specified cursor.
         """
         if self._continuation_prompt_html is None:
             self._insert_plain_text(cursor, self._continuation_prompt)
         else:
             self._continuation_prompt = self._insert_html_fetching_plain_text(
                 cursor, self._continuation_prompt_html)
 
     def _insert_block(self, cursor, block_format=None):
         """ Inserts an empty QTextBlock using the specified cursor.
         """
         if block_format is None:
             block_format = QtGui.QTextBlockFormat()
         cursor.insertBlock(block_format)
 
     def _insert_html(self, cursor, html):
         """ Inserts HTML using the specified cursor in such a way that future
             formatting is unaffected.
         """
         cursor.beginEditBlock()
         cursor.insertHtml(html)
 
         # After inserting HTML, the text document "remembers" it's in "html
         # mode", which means that subsequent calls adding plain text will result
         # in unwanted formatting, lost tab characters, etc. The following code
         # hacks around this behavior, which I consider to be a bug in Qt, by
         # (crudely) resetting the document's style state.
         cursor.movePosition(QtGui.QTextCursor.Left,
                             QtGui.QTextCursor.KeepAnchor)
         if cursor.selection().toPlainText() == ' ':
             cursor.removeSelectedText()
         else:
             cursor.movePosition(QtGui.QTextCursor.Right)
         cursor.insertText(' ', QtGui.QTextCharFormat())
         cursor.endEditBlock()
 
     def _insert_html_fetching_plain_text(self, cursor, html):
         """ Inserts HTML using the specified cursor, then returns its plain text
             version.
         """
         cursor.beginEditBlock()
         cursor.removeSelectedText()
 
         start = cursor.position()
         self._insert_html(cursor, html)
         end = cursor.position()
         cursor.setPosition(start, QtGui.QTextCursor.KeepAnchor)
         text = cursor.selection().toPlainText()
 
         cursor.setPosition(end)
         cursor.endEditBlock()
         return text
 
     def _insert_plain_text(self, cursor, text):
         """ Inserts plain text using the specified cursor, processing ANSI codes
             if enabled.
         """
         cursor.beginEditBlock()
         if self.ansi_codes:
             for substring in self._ansi_processor.split_string(text):
                 for act in self._ansi_processor.actions:
 
                     # Unlike real terminal emulators, we don't distinguish
                     # between the screen and the scrollback buffer. A screen
                     # erase request clears everything.
                     if act.action == 'erase' and act.area == 'screen':
                         cursor.select(QtGui.QTextCursor.Document)
                         cursor.removeSelectedText()
 
                     # Simulate a form feed by scrolling just past the last line.
                     elif act.action == 'scroll' and act.unit == 'page':
                         cursor.insertText('\n')
                         cursor.endEditBlock()
                         self._set_top_cursor(cursor)
                         cursor.joinPreviousEditBlock()
                         cursor.deletePreviousChar()
 
                     elif act.action == 'carriage-return':
                         cursor.movePosition(
                             cursor.StartOfLine, cursor.KeepAnchor)
 
                     elif act.action == 'beep':
                         QtGui.qApp.beep()
 
                     elif act.action == 'backspace':
                         if not cursor.atBlockStart():
                             cursor.movePosition(
                                 cursor.PreviousCharacter, cursor.KeepAnchor)
 
                     elif act.action == 'newline':
                         cursor.movePosition(cursor.EndOfLine)
 
                 format = self._ansi_processor.get_format()
 
                 selection = cursor.selectedText()
                 if len(selection) == 0:
                     cursor.insertText(substring, format)
                 elif substring is not None:
                     # BS and CR are treated as a change in print
                     # position, rather than a backwards character
                     # deletion for output equivalence with (I)Python
                     # terminal.
                     if len(substring) >= len(selection):
                         cursor.insertText(substring, format)
                     else:
                         old_text = selection[len(substring):]
                         cursor.insertText(substring + old_text, format)
                         cursor.movePosition(cursor.PreviousCharacter,
                                cursor.KeepAnchor, len(old_text))
         else:
             cursor.insertText(text)
         cursor.endEditBlock()
 
     def _insert_plain_text_into_buffer(self, cursor, text):
         """ Inserts text into the input buffer using the specified cursor (which
             must be in the input buffer), ensuring that continuation prompts are
             inserted as necessary.
         """
         lines = text.splitlines(True)
         if lines:
             cursor.beginEditBlock()
             cursor.insertText(lines[0])
             for line in lines[1:]:
                 if self._continuation_prompt_html is None:
                     cursor.insertText(self._continuation_prompt)
                 else:
                     self._continuation_prompt = \
                         self._insert_html_fetching_plain_text(
                             cursor, self._continuation_prompt_html)
                 cursor.insertText(line)
             cursor.endEditBlock()
 
     def _in_buffer(self, position=None):
         """ Returns whether the current cursor (or, if specified, a position) is
             inside the editing region.
         """
         cursor = self._control.textCursor()
         if position is None:
             position = cursor.position()
         else:
             cursor.setPosition(position)
         line = cursor.blockNumber()
         prompt_line = self._get_prompt_cursor().blockNumber()
         if line == prompt_line:
             return position >= self._prompt_pos
         elif line > prompt_line:
             cursor.movePosition(QtGui.QTextCursor.StartOfBlock)
             prompt_pos = cursor.position() + len(self._continuation_prompt)
             return position >= prompt_pos
         return False
 
     def _keep_cursor_in_buffer(self):
         """ Ensures that the cursor is inside the editing region. Returns
             whether the cursor was moved.
         """
         moved = not self._in_buffer()
         if moved:
             cursor = self._control.textCursor()
             cursor.movePosition(QtGui.QTextCursor.End)
             self._control.setTextCursor(cursor)
         return moved
 
     def _keyboard_quit(self):
         """ Cancels the current editing task ala Ctrl-G in Emacs.
         """
         if self._temp_buffer_filled :
             self._cancel_completion()
             self._clear_temporary_buffer()
         else:
             self.input_buffer = ''
 
     def _page(self, text, html=False):
         """ Displays text using the pager if it exceeds the height of the
         viewport.
 
         Parameters:
         -----------
         html : bool, optional (default False)
             If set, the text will be interpreted as HTML instead of plain text.
         """
         line_height = QtGui.QFontMetrics(self.font).height()
         minlines = self._control.viewport().height() / line_height
         if self.paging != 'none' and \
                 re.match("(?:[^\n]*\n){%i}" % minlines, text):
             if self.paging == 'custom':
                 self.custom_page_requested.emit(text)
             else:
                 self._page_control.clear()
                 cursor = self._page_control.textCursor()
                 if html:
                     self._insert_html(cursor, text)
                 else:
                     self._insert_plain_text(cursor, text)
                 self._page_control.moveCursor(QtGui.QTextCursor.Start)
 
                 self._page_control.viewport().resize(self._control.size())
                 if self._splitter:
                     self._page_control.show()
                     self._page_control.setFocus()
                 else:
                     self.layout().setCurrentWidget(self._page_control)
         elif html:
             self._append_html(text)
         else:
             self._append_plain_text(text)
 
     def _set_paging(self, paging):
         """
         Change the pager to `paging` style.
 
         XXX: currently, this is limited to switching between 'hsplit' and
         'vsplit'.
 
         Parameters:
         -----------
         paging : string
             Either "hsplit", "vsplit", or "inside"
         """
         if self._splitter is None:
             raise NotImplementedError("""can only switch if --paging=hsplit or
                     --paging=vsplit is used.""")
         if paging == 'hsplit':
             self._splitter.setOrientation(QtCore.Qt.Horizontal)
         elif paging == 'vsplit':
             self._splitter.setOrientation(QtCore.Qt.Vertical)
         elif paging == 'inside':
             raise NotImplementedError("""switching to 'inside' paging not
                     supported yet.""")
         else:
             raise ValueError("unknown paging method '%s'" % paging)
         self.paging = paging
 
     def _prompt_finished(self):
         """ Called immediately after a prompt is finished, i.e. when some input
             will be processed and a new prompt displayed.
         """
         self._control.setReadOnly(True)
         self._prompt_finished_hook()
 
     def _prompt_started(self):
         """ Called immediately after a new prompt is displayed.
         """
         # Temporarily disable the maximum block count to permit undo/redo and
         # to ensure that the prompt position does not change due to truncation.
         self._control.document().setMaximumBlockCount(0)
         self._control.setUndoRedoEnabled(True)
 
         # Work around bug in QPlainTextEdit: input method is not re-enabled
         # when read-only is disabled.
         self._control.setReadOnly(False)
         self._control.setAttribute(QtCore.Qt.WA_InputMethodEnabled, True)
 
         if not self._reading:
             self._executing = False
         self._prompt_started_hook()
 
         # If the input buffer has changed while executing, load it.
         if self._input_buffer_pending:
             self.input_buffer = self._input_buffer_pending
             self._input_buffer_pending = ''
 
         self._control.moveCursor(QtGui.QTextCursor.End)
 
     def _readline(self, prompt='', callback=None):
         """ Reads one line of input from the user.
 
         Parameters
         ----------
         prompt : str, optional
             The prompt to print before reading the line.
 
         callback : callable, optional
             A callback to execute with the read line. If not specified, input is
             read *synchronously* and this method does not return until it has
             been read.
 
         Returns
         -------
         If a callback is specified, returns nothing. Otherwise, returns the
         input string with the trailing newline stripped.
         """
         if self._reading:
             raise RuntimeError('Cannot read a line. Widget is already reading.')
 
         if not callback and not self.isVisible():
             # If the user cannot see the widget, this function cannot return.
             raise RuntimeError('Cannot synchronously read a line if the widget '
                                'is not visible!')
 
         self._reading = True
         self._show_prompt(prompt, newline=False)
 
         if callback is None:
             self._reading_callback = None
             while self._reading:
                 QtCore.QCoreApplication.processEvents()
             return self._get_input_buffer(force=True).rstrip('\n')
 
         else:
             self._reading_callback = lambda: \
                 callback(self._get_input_buffer(force=True).rstrip('\n'))
 
     def _set_continuation_prompt(self, prompt, html=False):
         """ Sets the continuation prompt.
 
         Parameters
         ----------
         prompt : str
             The prompt to show when more input is needed.
 
         html : bool, optional (default False)
             If set, the prompt will be inserted as formatted HTML. Otherwise,
             the prompt will be treated as plain text, though ANSI color codes
             will be handled.
         """
         if html:
             self._continuation_prompt_html = prompt
         else:
             self._continuation_prompt = prompt
             self._continuation_prompt_html = None
 
     def _set_cursor(self, cursor):
         """ Convenience method to set the current cursor.
         """
         self._control.setTextCursor(cursor)
 
     def _set_top_cursor(self, cursor):
         """ Scrolls the viewport so that the specified cursor is at the top.
         """
         scrollbar = self._control.verticalScrollBar()
         scrollbar.setValue(scrollbar.maximum())
         original_cursor = self._control.textCursor()
         self._control.setTextCursor(cursor)
         self._control.ensureCursorVisible()
         self._control.setTextCursor(original_cursor)
 
     def _show_prompt(self, prompt=None, html=False, newline=True):
         """ Writes a new prompt at the end of the buffer.
 
         Parameters
         ----------
         prompt : str, optional
             The prompt to show. If not specified, the previous prompt is used.
 
         html : bool, optional (default False)
             Only relevant when a prompt is specified. If set, the prompt will
             be inserted as formatted HTML. Otherwise, the prompt will be treated
             as plain text, though ANSI color codes will be handled.
 
         newline : bool, optional (default True)
             If set, a new line will be written before showing the prompt if
             there is not already a newline at the end of the buffer.
         """
         # Save the current end position to support _append*(before_prompt=True).
         cursor = self._get_end_cursor()
         self._append_before_prompt_pos = cursor.position()
 
         # Insert a preliminary newline, if necessary.
         if newline and cursor.position() > 0:
             cursor.movePosition(QtGui.QTextCursor.Left,
                                 QtGui.QTextCursor.KeepAnchor)
             if cursor.selection().toPlainText() != '\n':
                 self._append_block()
 
         # Write the prompt.
         self._append_plain_text(self._prompt_sep)
         if prompt is None:
             if self._prompt_html is None:
                 self._append_plain_text(self._prompt)
             else:
                 self._append_html(self._prompt_html)
         else:
             if html:
                 self._prompt = self._append_html_fetching_plain_text(prompt)
                 self._prompt_html = prompt
             else:
                 self._append_plain_text(prompt)
                 self._prompt = prompt
                 self._prompt_html = None
 
         self._prompt_pos = self._get_end_cursor().position()
         self._prompt_started()
 
     #------ Signal handlers ----------------------------------------------------
 
     def _adjust_scrollbars(self):
         """ Expands the vertical scrollbar beyond the range set by Qt.
         """
         # This code is adapted from _q_adjustScrollbars in qplaintextedit.cpp
         # and qtextedit.cpp.
         document = self._control.document()
         scrollbar = self._control.verticalScrollBar()
         viewport_height = self._control.viewport().height()
         if isinstance(self._control, QtGui.QPlainTextEdit):
             maximum = max(0, document.lineCount() - 1)
             step = viewport_height / self._control.fontMetrics().lineSpacing()
         else:
             # QTextEdit does not do line-based layout and blocks will not in
             # general have the same height. Therefore it does not make sense to
             # attempt to scroll in line height increments.
             maximum = document.size().height()
             step = viewport_height
         diff = maximum - scrollbar.maximum()
         scrollbar.setRange(0, maximum)
         scrollbar.setPageStep(step)
 
         # Compensate for undesirable scrolling that occurs automatically due to
         # maximumBlockCount() text truncation.
         if diff < 0 and document.blockCount() == document.maximumBlockCount():
             scrollbar.setValue(scrollbar.value() + diff)
 
     def _custom_context_menu_requested(self, pos):
         """ Shows a context menu at the given QPoint (in widget coordinates).
         """
         menu = self._context_menu_make(pos)
         menu.exec_(self._control.mapToGlobal(pos))

IPython/qt/console/frontend_widget.py

@@ -1,785 +1,785 b''
 from __future__ import print_function
 
 # Standard library imports
 from collections import namedtuple
 import sys
 import time
 import uuid
 
 # System library imports
 from pygments.lexers import PythonLexer
 from IPython.external import qt
 from IPython.external.qt import QtCore, QtGui
 
 # Local imports
 from IPython.core.inputsplitter import InputSplitter, IPythonInputSplitter
 from IPython.core.inputtransformer import classic_prompt
 from IPython.core.oinspect import call_tip
-from IPython.frontend.qt.base_frontend_mixin import BaseFrontendMixin
+from IPython.qt.base_frontend_mixin import BaseFrontendMixin
 from IPython.utils.traitlets import Bool, Instance, Unicode
 from bracket_matcher import BracketMatcher
 from call_tip_widget import CallTipWidget
 from completion_lexer import CompletionLexer
 from history_console_widget import HistoryConsoleWidget
 from pygments_highlighter import PygmentsHighlighter
 
 
 class FrontendHighlighter(PygmentsHighlighter):
     """ A PygmentsHighlighter that understands and ignores prompts.
     """
 
     def __init__(self, frontend):
         super(FrontendHighlighter, self).__init__(frontend._control.document())
         self._current_offset = 0
         self._frontend = frontend
         self.highlighting_on = False
 
     def highlightBlock(self, string):
         """ Highlight a block of text. Reimplemented to highlight selectively.
         """
         if not self.highlighting_on:
             return
 
         # The input to this function is a unicode string that may contain
         # paragraph break characters, non-breaking spaces, etc. Here we acquire
         # the string as plain text so we can compare it.
         current_block = self.currentBlock()
         string = self._frontend._get_block_plain_text(current_block)
 
         # Decide whether to check for the regular or continuation prompt.
         if current_block.contains(self._frontend._prompt_pos):
             prompt = self._frontend._prompt
         else:
             prompt = self._frontend._continuation_prompt
 
         # Only highlight if we can identify a prompt, but make sure not to
         # highlight the prompt.
         if string.startswith(prompt):
             self._current_offset = len(prompt)
             string = string[len(prompt):]
             super(FrontendHighlighter, self).highlightBlock(string)
 
     def rehighlightBlock(self, block):
         """ Reimplemented to temporarily enable highlighting if disabled.
         """
         old = self.highlighting_on
         self.highlighting_on = True
         super(FrontendHighlighter, self).rehighlightBlock(block)
         self.highlighting_on = old
 
     def setFormat(self, start, count, format):
         """ Reimplemented to highlight selectively.
         """
         start += self._current_offset
         super(FrontendHighlighter, self).setFormat(start, count, format)
 
 
 class FrontendWidget(HistoryConsoleWidget, BaseFrontendMixin):
     """ A Qt frontend for a generic Python kernel.
     """
 
     # The text to show when the kernel is (re)started.
     banner = Unicode()
 
     # An option and corresponding signal for overriding the default kernel
     # interrupt behavior.
     custom_interrupt = Bool(False)
     custom_interrupt_requested = QtCore.Signal()
 
     # An option and corresponding signals for overriding the default kernel
     # restart behavior.
     custom_restart = Bool(False)
     custom_restart_kernel_died = QtCore.Signal(float)
     custom_restart_requested = QtCore.Signal()
 
     # Whether to automatically show calltips on open-parentheses.
     enable_calltips = Bool(True, config=True,
         help="Whether to draw information calltips on open-parentheses.")
 
     clear_on_kernel_restart = Bool(True, config=True,
         help="Whether to clear the console when the kernel is restarted")
 
     confirm_restart = Bool(True, config=True,
         help="Whether to ask for user confirmation when restarting kernel")
 
     # Emitted when a user visible 'execute_request' has been submitted to the
     # kernel from the FrontendWidget. Contains the code to be executed.
     executing = QtCore.Signal(object)
 
     # Emitted when a user-visible 'execute_reply' has been received from the
     # kernel and processed by the FrontendWidget. Contains the response message.
     executed = QtCore.Signal(object)
 
     # Emitted when an exit request has been received from the kernel.
     exit_requested = QtCore.Signal(object)
 
     # Protected class variables.
     _prompt_transformer = IPythonInputSplitter(physical_line_transforms=[classic_prompt()],
                                                logical_line_transforms=[],
                                                python_line_transforms=[],
                                               )
     _CallTipRequest = namedtuple('_CallTipRequest', ['id', 'pos'])
     _CompletionRequest = namedtuple('_CompletionRequest', ['id', 'pos'])
     _ExecutionRequest = namedtuple('_ExecutionRequest', ['id', 'kind'])
     _input_splitter_class = InputSplitter
     _local_kernel = False
     _highlighter = Instance(FrontendHighlighter)
 
     #---------------------------------------------------------------------------
     # 'object' interface
     #---------------------------------------------------------------------------
 
     def __init__(self, *args, **kw):
         super(FrontendWidget, self).__init__(*args, **kw)
         # FIXME: remove this when PySide min version is updated past 1.0.7
         # forcefully disable calltips if PySide is < 1.0.7, because they crash
         if qt.QT_API == qt.QT_API_PYSIDE:
             import PySide
             if PySide.__version_info__ < (1,0,7):
                 self.log.warn("PySide %s < 1.0.7 detected, disabling calltips" % PySide.__version__)
                 self.enable_calltips = False
 
         # FrontendWidget protected variables.
         self._bracket_matcher = BracketMatcher(self._control)
         self._call_tip_widget = CallTipWidget(self._control)
         self._completion_lexer = CompletionLexer(PythonLexer())
         self._copy_raw_action = QtGui.QAction('Copy (Raw Text)', None)
         self._hidden = False
         self._highlighter = FrontendHighlighter(self)
         self._input_splitter = self._input_splitter_class()
         self._kernel_manager = None
         self._kernel_client = None
         self._request_info = {}
         self._request_info['execute'] = {};
         self._callback_dict = {}
 
         # Configure the ConsoleWidget.
         self.tab_width = 4
         self._set_continuation_prompt('... ')
 
         # Configure the CallTipWidget.
         self._call_tip_widget.setFont(self.font)
         self.font_changed.connect(self._call_tip_widget.setFont)
 
         # Configure actions.
         action = self._copy_raw_action
         key = QtCore.Qt.CTRL | QtCore.Qt.SHIFT | QtCore.Qt.Key_C
         action.setEnabled(False)
         action.setShortcut(QtGui.QKeySequence(key))
         action.setShortcutContext(QtCore.Qt.WidgetWithChildrenShortcut)
         action.triggered.connect(self.copy_raw)
         self.copy_available.connect(action.setEnabled)
         self.addAction(action)
 
         # Connect signal handlers.
         document = self._control.document()
         document.contentsChange.connect(self._document_contents_change)
 
         # Set flag for whether we are connected via localhost.
         self._local_kernel = kw.get('local_kernel',
                                     FrontendWidget._local_kernel)
 
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' public interface
     #---------------------------------------------------------------------------
 
     def copy(self):
         """ Copy the currently selected text to the clipboard, removing prompts.
         """
         if self._page_control is not None and self._page_control.hasFocus():
             self._page_control.copy()
         elif self._control.hasFocus():
             text = self._control.textCursor().selection().toPlainText()
             if text:
                 text = self._prompt_transformer.transform_cell(text)
                 QtGui.QApplication.clipboard().setText(text)
         else:
             self.log.debug("frontend widget : unknown copy target")
 
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' abstract interface
     #---------------------------------------------------------------------------
 
     def _is_complete(self, source, interactive):
         """ Returns whether 'source' can be completely processed and a new
             prompt created. When triggered by an Enter/Return key press,
             'interactive' is True; otherwise, it is False.
         """
         self._input_splitter.reset()
         complete = self._input_splitter.push(source)
         if interactive:
             complete = not self._input_splitter.push_accepts_more()
         return complete
 
     def _execute(self, source, hidden):
         """ Execute 'source'. If 'hidden', do not show any output.
 
         See parent class :meth:`execute` docstring for full details.
         """
         msg_id = self.kernel_client.execute(source, hidden)
         self._request_info['execute'][msg_id] = self._ExecutionRequest(msg_id, 'user')
         self._hidden = hidden
         if not hidden:
             self.executing.emit(source)
 
     def _prompt_started_hook(self):
         """ Called immediately after a new prompt is displayed.
         """
         if not self._reading:
             self._highlighter.highlighting_on = True
 
     def _prompt_finished_hook(self):
         """ Called immediately after a prompt is finished, i.e. when some input
             will be processed and a new prompt displayed.
         """
         # Flush all state from the input splitter so the next round of
         # reading input starts with a clean buffer.
         self._input_splitter.reset()
 
         if not self._reading:
             self._highlighter.highlighting_on = False
 
     def _tab_pressed(self):
         """ Called when the tab key is pressed. Returns whether to continue
             processing the event.
         """
         # Perform tab completion if:
         # 1) The cursor is in the input buffer.
         # 2) There is a non-whitespace character before the cursor.
         text = self._get_input_buffer_cursor_line()
         if text is None:
             return False
         complete = bool(text[:self._get_input_buffer_cursor_column()].strip())
         if complete:
             self._complete()
         return not complete
 
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' protected interface
     #---------------------------------------------------------------------------
 
     def _context_menu_make(self, pos):
         """ Reimplemented to add an action for raw copy.
         """
         menu = super(FrontendWidget, self)._context_menu_make(pos)
         for before_action in menu.actions():
             if before_action.shortcut().matches(QtGui.QKeySequence.Paste) == \
                     QtGui.QKeySequence.ExactMatch:
                 menu.insertAction(before_action, self._copy_raw_action)
                 break
         return menu
 
     def request_interrupt_kernel(self):
         if self._executing:
             self.interrupt_kernel()
 
     def request_restart_kernel(self):
         message = 'Are you sure you want to restart the kernel?'
         self.restart_kernel(message, now=False)
 
     def _event_filter_console_keypress(self, event):
         """ Reimplemented for execution interruption and smart backspace.
         """
         key = event.key()
         if self._control_key_down(event.modifiers(), include_command=False):
 
             if key == QtCore.Qt.Key_C and self._executing:
                 self.request_interrupt_kernel()
                 return True
 
             elif key == QtCore.Qt.Key_Period:
                 self.request_restart_kernel()
                 return True
 
         elif not event.modifiers() & QtCore.Qt.AltModifier:
 
             # Smart backspace: remove four characters in one backspace if:
             # 1) everything left of the cursor is whitespace
             # 2) the four characters immediately left of the cursor are spaces
             if key == QtCore.Qt.Key_Backspace:
                 col = self._get_input_buffer_cursor_column()
                 cursor = self._control.textCursor()
                 if col > 3 and not cursor.hasSelection():
                     text = self._get_input_buffer_cursor_line()[:col]
                     if text.endswith('    ') and not text.strip():
                         cursor.movePosition(QtGui.QTextCursor.Left,
                                             QtGui.QTextCursor.KeepAnchor, 4)
                         cursor.removeSelectedText()
                         return True
 
         return super(FrontendWidget, self)._event_filter_console_keypress(event)
 
     def _insert_continuation_prompt(self, cursor):
         """ Reimplemented for auto-indentation.
         """
         super(FrontendWidget, self)._insert_continuation_prompt(cursor)
         cursor.insertText(' ' * self._input_splitter.indent_spaces)
 
     #---------------------------------------------------------------------------
     # 'BaseFrontendMixin' abstract interface
     #---------------------------------------------------------------------------
 
     def _handle_complete_reply(self, rep):
         """ Handle replies for tab completion.
         """
         self.log.debug("complete: %s", rep.get('content', ''))
         cursor = self._get_cursor()
         info = self._request_info.get('complete')
         if info and info.id == rep['parent_header']['msg_id'] and \
                 info.pos == cursor.position():
             text = '.'.join(self._get_context())
             cursor.movePosition(QtGui.QTextCursor.Left, n=len(text))
             self._complete_with_items(cursor, rep['content']['matches'])
 
     def _silent_exec_callback(self, expr, callback):
         """Silently execute `expr` in the kernel and call `callback` with reply
 
         the `expr` is evaluated silently in the kernel (without) output in
         the frontend. Call `callback` with the
         `repr <http://docs.python.org/library/functions.html#repr> `_ as first argument
 
         Parameters
         ----------
         expr : string
             valid string to be executed by the kernel.
         callback : function
             function accepting one argument, as a string. The string will be
             the `repr` of the result of evaluating `expr`
 
         The `callback` is called with the `repr()` of the result of `expr` as
         first argument. To get the object, do `eval()` on the passed value.
 
         See Also
         --------
         _handle_exec_callback : private method, deal with calling callback with reply
 
         """
 
         # generate uuid, which would be used as an indication of whether or
         # not the unique request originated from here (can use msg id ?)
         local_uuid = str(uuid.uuid1())
         msg_id = self.kernel_client.execute('',
             silent=True, user_expressions={ local_uuid:expr })
         self._callback_dict[local_uuid] = callback
         self._request_info['execute'][msg_id] = self._ExecutionRequest(msg_id, 'silent_exec_callback')
 
     def _handle_exec_callback(self, msg):
         """Execute `callback` corresponding to `msg` reply, after ``_silent_exec_callback``
 
         Parameters
         ----------
         msg : raw message send by the kernel containing an `user_expressions`
                 and having a 'silent_exec_callback' kind.
 
         Notes
         -----
         This function will look for a `callback` associated with the
         corresponding message id. Association has been made by
         `_silent_exec_callback`. `callback` is then called with the `repr()`
         of the value of corresponding `user_expressions` as argument.
         `callback` is then removed from the known list so that any message
         coming again with the same id won't trigger it.
 
         """
 
         user_exp = msg['content'].get('user_expressions')
         if not user_exp:
             return
         for expression in user_exp:
             if expression in self._callback_dict:
                 self._callback_dict.pop(expression)(user_exp[expression])
 
     def _handle_execute_reply(self, msg):
         """ Handles replies for code execution.
         """
         self.log.debug("execute: %s", msg.get('content', ''))
         msg_id = msg['parent_header']['msg_id']
         info = self._request_info['execute'].get(msg_id)
         # unset reading flag, because if execute finished, raw_input can't
         # still be pending.
         self._reading = False
         if info and info.kind == 'user' and not self._hidden:
             # Make sure that all output from the SUB channel has been processed
             # before writing a new prompt.
             self.kernel_client.iopub_channel.flush()
 
             # Reset the ANSI style information to prevent bad text in stdout
             # from messing up our colors. We're not a true terminal so we're
             # allowed to do this.
             if self.ansi_codes:
                 self._ansi_processor.reset_sgr()
 
             content = msg['content']
             status = content['status']
             if status == 'ok':
                 self._process_execute_ok(msg)
             elif status == 'error':
                 self._process_execute_error(msg)
             elif status == 'aborted':
                 self._process_execute_abort(msg)
 
             self._show_interpreter_prompt_for_reply(msg)
             self.executed.emit(msg)
             self._request_info['execute'].pop(msg_id)
         elif info and info.kind == 'silent_exec_callback' and not self._hidden:
             self._handle_exec_callback(msg)
             self._request_info['execute'].pop(msg_id)
         else:
             super(FrontendWidget, self)._handle_execute_reply(msg)
 
     def _handle_input_request(self, msg):
         """ Handle requests for raw_input.
         """
         self.log.debug("input: %s", msg.get('content', ''))
         if self._hidden:
             raise RuntimeError('Request for raw input during hidden execution.')
 
         # Make sure that all output from the SUB channel has been processed
         # before entering readline mode.
         self.kernel_client.iopub_channel.flush()
 
         def callback(line):
             self.kernel_client.stdin_channel.input(line)
         if self._reading:
             self.log.debug("Got second input request, assuming first was interrupted.")
             self._reading = False
         self._readline(msg['content']['prompt'], callback=callback)
 
     def _kernel_restarted_message(self, died=True):
         msg = "Kernel died, restarting" if died else "Kernel restarting"
         self._append_html("<br>%s<hr><br>" % msg,
             before_prompt=False
         )
 
     def _handle_kernel_died(self, since_last_heartbeat):
         """Handle the kernel's death (if we do not own the kernel).
         """
         self.log.warn("kernel died: %s", since_last_heartbeat)
         if self.custom_restart:
             self.custom_restart_kernel_died.emit(since_last_heartbeat)
         else:
             self._kernel_restarted_message(died=True)
             self.reset()
 
     def _handle_kernel_restarted(self, died=True):
         """Notice that the autorestarter restarted the kernel.
 
         There's nothing to do but show a message.
         """
         self.log.warn("kernel restarted")
         self._kernel_restarted_message(died=died)
         self.reset()
 
     def _handle_object_info_reply(self, rep):
         """ Handle replies for call tips.
         """
         self.log.debug("oinfo: %s", rep.get('content', ''))
         cursor = self._get_cursor()
         info = self._request_info.get('call_tip')
         if info and info.id == rep['parent_header']['msg_id'] and \
                 info.pos == cursor.position():
             # Get the information for a call tip.  For now we format the call
             # line as string, later we can pass False to format_call and
             # syntax-highlight it ourselves for nicer formatting in the
             # calltip.
             content = rep['content']
             # if this is from pykernel, 'docstring' will be the only key
             if content.get('ismagic', False):
                 # Don't generate a call-tip for magics. Ideally, we should
                 # generate a tooltip, but not on ( like we do for actual
                 # callables.
                 call_info, doc = None, None
             else:
                 call_info, doc = call_tip(content, format_call=True)
             if call_info or doc:
                 self._call_tip_widget.show_call_info(call_info, doc)
 
     def _handle_pyout(self, msg):
         """ Handle display hook output.
         """
         self.log.debug("pyout: %s", msg.get('content', ''))
         if not self._hidden and self._is_from_this_session(msg):
             text = msg['content']['data']
             self._append_plain_text(text + '\n', before_prompt=True)
 
     def _handle_stream(self, msg):
         """ Handle stdout, stderr, and stdin.
         """
         self.log.debug("stream: %s", msg.get('content', ''))
         if not self._hidden and self._is_from_this_session(msg):
             # Most consoles treat tabs as being 8 space characters. Convert tabs
             # to spaces so that output looks as expected regardless of this
             # widget's tab width.
             text = msg['content']['data'].expandtabs(8)
 
             self._append_plain_text(text, before_prompt=True)
             self._control.moveCursor(QtGui.QTextCursor.End)
 
     def _handle_shutdown_reply(self, msg):
         """ Handle shutdown signal, only if from other console.
         """
         self.log.warn("shutdown: %s", msg.get('content', ''))
         restart = msg.get('content', {}).get('restart', False)
         if not self._hidden and not self._is_from_this_session(msg):
             # got shutdown reply, request came from session other than ours
             if restart:
                 # someone restarted the kernel, handle it
                 self._handle_kernel_restarted(died=False)
             else:
                 # kernel was shutdown permanently
                 # this triggers exit_requested if the kernel was local,
                 # and a dialog if the kernel was remote,
                 # so we don't suddenly clear the qtconsole without asking.
                 if self._local_kernel:
                     self.exit_requested.emit(self)
                 else:
                     title = self.window().windowTitle()
                     reply = QtGui.QMessageBox.question(self, title,
                         "Kernel has been shutdown permanently. "
                         "Close the Console?",
                         QtGui.QMessageBox.Yes,QtGui.QMessageBox.No)
                     if reply == QtGui.QMessageBox.Yes:
                         self.exit_requested.emit(self)
 
     def _handle_status(self, msg):
         """Handle status message"""
         # This is where a busy/idle indicator would be triggered,
         # when we make one.
         state = msg['content'].get('execution_state', '')
         if state == 'starting':
             # kernel started while we were running
             if self._executing:
                 self._handle_kernel_restarted(died=True)
         elif state == 'idle':
             pass
         elif state == 'busy':
             pass
 
     def _started_channels(self):
         """ Called when the KernelManager channels have started listening or
             when the frontend is assigned an already listening KernelManager.
         """
         self.reset(clear=True)
 
     #---------------------------------------------------------------------------
     # 'FrontendWidget' public interface
     #---------------------------------------------------------------------------
 
     def copy_raw(self):
         """ Copy the currently selected text to the clipboard without attempting
             to remove prompts or otherwise alter the text.
         """
         self._control.copy()
 
     def execute_file(self, path, hidden=False):
         """ Attempts to execute file with 'path'. If 'hidden', no output is
             shown.
         """
         self.execute('execfile(%r)' % path, hidden=hidden)
 
     def interrupt_kernel(self):
         """ Attempts to interrupt the running kernel.
         
         Also unsets _reading flag, to avoid runtime errors
         if raw_input is called again.
         """
         if self.custom_interrupt:
             self._reading = False
             self.custom_interrupt_requested.emit()
         elif self.kernel_manager:
             self._reading = False
             self.kernel_manager.interrupt_kernel()
         else:
             self._append_plain_text('Cannot interrupt a kernel I did not start.\n')
 
     def reset(self, clear=False):
         """ Resets the widget to its initial state if ``clear`` parameter
         is True, otherwise
         prints a visual indication of the fact that the kernel restarted, but
         does not clear the traces from previous usage of the kernel before it
         was restarted.  With ``clear=True``, it is similar to ``%clear``, but
         also re-writes the banner and aborts execution if necessary.
         """
         if self._executing:
             self._executing = False
             self._request_info['execute'] = {}
         self._reading = False
         self._highlighter.highlighting_on = False
 
         if clear:
             self._control.clear()
             self._append_plain_text(self.banner)
         # update output marker for stdout/stderr, so that startup
         # messages appear after banner:
         self._append_before_prompt_pos = self._get_cursor().position()
         self._show_interpreter_prompt()
 
     def restart_kernel(self, message, now=False):
         """ Attempts to restart the running kernel.
         """
         # FIXME: now should be configurable via a checkbox in the dialog.  Right
         # now at least the heartbeat path sets it to True and the manual restart
         # to False.  But those should just be the pre-selected states of a
         # checkbox that the user could override if so desired.  But I don't know
         # enough Qt to go implementing the checkbox now.
 
         if self.custom_restart:
             self.custom_restart_requested.emit()
             return
 
         if self.kernel_manager:
             # Pause the heart beat channel to prevent further warnings.
             self.kernel_client.hb_channel.pause()
 
             # Prompt the user to restart the kernel. Un-pause the heartbeat if
             # they decline. (If they accept, the heartbeat will be un-paused
             # automatically when the kernel is restarted.)
             if self.confirm_restart:
                 buttons = QtGui.QMessageBox.Yes | QtGui.QMessageBox.No
                 result = QtGui.QMessageBox.question(self, 'Restart kernel?',
                                                     message, buttons)
                 do_restart = result == QtGui.QMessageBox.Yes
             else:
                 # confirm_restart is False, so we don't need to ask user
                 # anything, just do the restart
                 do_restart = True
             if do_restart:
                 try:
                     self.kernel_manager.restart_kernel(now=now)
                 except RuntimeError as e:
                     self._append_plain_text(
                         'Error restarting kernel: %s\n' % e,
                         before_prompt=True
                     )
                 else:
                     self._append_html("<br>Restarting kernel...\n<hr><br>",
                         before_prompt=True,
                     )
             else:
                 self.kernel_client.hb_channel.unpause()
 
         else:
             self._append_plain_text(
                 'Cannot restart a Kernel I did not start\n',
                 before_prompt=True
             )
 
     #---------------------------------------------------------------------------
     # 'FrontendWidget' protected interface
     #---------------------------------------------------------------------------
 
     def _call_tip(self):
         """ Shows a call tip, if appropriate, at the current cursor location.
         """
         # Decide if it makes sense to show a call tip
         if not self.enable_calltips:
             return False
         cursor = self._get_cursor()
         cursor.movePosition(QtGui.QTextCursor.Left)
         if cursor.document().characterAt(cursor.position()) != '(':
             return False
         context = self._get_context(cursor)
         if not context:
             return False
 
         # Send the metadata request to the kernel
         name = '.'.join(context)
         msg_id = self.kernel_client.object_info(name)
         pos = self._get_cursor().position()
         self._request_info['call_tip'] = self._CallTipRequest(msg_id, pos)
         return True
 
     def _complete(self):
         """ Performs completion at the current cursor location.
         """
         context = self._get_context()
         if context:
             # Send the completion request to the kernel
             msg_id = self.kernel_client.complete(
                 '.'.join(context),                       # text
                 self._get_input_buffer_cursor_line(),    # line
                 self._get_input_buffer_cursor_column(),  # cursor_pos
                 self.input_buffer)                       # block
             pos = self._get_cursor().position()
             info = self._CompletionRequest(msg_id, pos)
             self._request_info['complete'] = info
 
     def _get_context(self, cursor=None):
         """ Gets the context for the specified cursor (or the current cursor
             if none is specified).
         """
         if cursor is None:
             cursor = self._get_cursor()
         cursor.movePosition(QtGui.QTextCursor.StartOfBlock,
                             QtGui.QTextCursor.KeepAnchor)
         text = cursor.selection().toPlainText()
         return self._completion_lexer.get_context(text)
 
     def _process_execute_abort(self, msg):
         """ Process a reply for an aborted execution request.
         """
         self._append_plain_text("ERROR: execution aborted\n")
 
     def _process_execute_error(self, msg):
         """ Process a reply for an execution request that resulted in an error.
         """
         content = msg['content']
         # If a SystemExit is passed along, this means exit() was called - also
         # all the ipython %exit magic syntax of '-k' to be used to keep
         # the kernel running
         if content['ename']=='SystemExit':
             keepkernel = content['evalue']=='-k' or content['evalue']=='True'
             self._keep_kernel_on_exit = keepkernel
             self.exit_requested.emit(self)
         else:
             traceback = ''.join(content['traceback'])
             self._append_plain_text(traceback)
 
     def _process_execute_ok(self, msg):
         """ Process a reply for a successful execution request.
         """
         payload = msg['content']['payload']
         for item in payload:
             if not self._process_execute_payload(item):
                 warning = 'Warning: received unknown payload of type %s'
                 print(warning % repr(item['source']))
 
     def _process_execute_payload(self, item):
         """ Process a single payload item from the list of payload items in an
             execution reply. Returns whether the payload was handled.
         """
         # The basic FrontendWidget doesn't handle payloads, as they are a
         # mechanism for going beyond the standard Python interpreter model.
         return False
 
     def _show_interpreter_prompt(self):
         """ Shows a prompt for the interpreter.
         """
         self._show_prompt('>>> ')
 
     def _show_interpreter_prompt_for_reply(self, msg):
         """ Shows a prompt for the interpreter given an 'execute_reply' message.
         """
         self._show_interpreter_prompt()
 
     #------ Signal handlers ----------------------------------------------------
 
     def _document_contents_change(self, position, removed, added):
         """ Called whenever the document's content changes. Display a call tip
             if appropriate.
         """
         # Calculate where the cursor should be *after* the change:
         position += added
 
         document = self._control.document()
         if position == self._get_cursor().position():
             self._call_tip()
 
     #------ Trait default initializers -----------------------------------------
 
     def _banner_default(self):
         """ Returns the standard Python banner.
         """
         banner = 'Python %s on %s\nType "help", "copyright", "credits" or ' \
             '"license" for more information.'
         return banner % (sys.version, sys.platform)

IPython/qt/console/qtconsoleapp.py

@@ -1,388 +1,388 b''
 """ A minimal application using the Qt console-style IPython frontend.
 
 This is not a complete console app, as subprocess will not be able to receive
 input, there is no real readline support, among other limitations.
 
 Authors:
 
 * Evan Patterson
 * Min RK
 * Erik Tollerud
 * Fernando Perez
 * Bussonnier Matthias
 * Thomas Kluyver
 * Paul Ivanov
 
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # stdlib imports
 import os
 import signal
 import sys
 
 # If run on Windows, install an exception hook which pops up a
 # message box. Pythonw.exe hides the console, so without this
 # the application silently fails to load.
 #
 # We always install this handler, because the expectation is for
 # qtconsole to bring up a GUI even if called from the console.
 # The old handler is called, so the exception is printed as well.
 # If desired, check for pythonw with an additional condition
 # (sys.executable.lower().find('pythonw.exe') >= 0).
 if os.name == 'nt':
     old_excepthook = sys.excepthook
 
     def gui_excepthook(exctype, value, tb):
         try:
             import ctypes, traceback
             MB_ICONERROR = 0x00000010L
             title = u'Error starting IPython QtConsole'
             msg = u''.join(traceback.format_exception(exctype, value, tb))
             ctypes.windll.user32.MessageBoxW(0, msg, title, MB_ICONERROR)
         finally:
             # Also call the old exception hook to let it do
             # its thing too.
             old_excepthook(exctype, value, tb)
 
     sys.excepthook = gui_excepthook
 
 # System library imports
 from IPython.external.qt import QtCore, QtGui
 
 # Local imports
 from IPython.config.application import boolean_flag, catch_config_error
 from IPython.core.application import BaseIPythonApplication
 from IPython.core.profiledir import ProfileDir
-from IPython.frontend.qt.console.ipython_widget import IPythonWidget
-from IPython.frontend.qt.console.rich_ipython_widget import RichIPythonWidget
-from IPython.frontend.qt.console import styles
-from IPython.frontend.qt.console.mainwindow import MainWindow
-from IPython.frontend.qt.client import QtKernelClient
-from IPython.frontend.qt.manager import QtKernelManager
+from IPython.qt.console.ipython_widget import IPythonWidget
+from IPython.qt.console.rich_ipython_widget import RichIPythonWidget
+from IPython.qt.console import styles
+from IPython.qt.console.mainwindow import MainWindow
+from IPython.qt.client import QtKernelClient
+from IPython.qt.manager import QtKernelManager
 from IPython.kernel import tunnel_to_kernel, find_connection_file
 from IPython.utils.traitlets import (
     Dict, List, Unicode, CBool, Any
 )
 from IPython.kernel.zmq.session import default_secure
 
-from IPython.frontend.consoleapp import (
+from IPython.consoleapp import (
         IPythonConsoleApp, app_aliases, app_flags, flags, aliases
     )
 
 #-----------------------------------------------------------------------------
 # Network Constants
 #-----------------------------------------------------------------------------
 
 from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 _examples = """
 ipython qtconsole                 # start the qtconsole
 ipython qtconsole --pylab=inline  # start with pylab in inline plotting mode
 """
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 
 # start with copy of flags
 flags = dict(flags)
 qt_flags = {
     'plain' : ({'IPythonQtConsoleApp' : {'plain' : True}},
             "Disable rich text support."),
 }
 
 # and app_flags from the Console Mixin
 qt_flags.update(app_flags)
 # add frontend flags to the full set
 flags.update(qt_flags)
 
 # start with copy of front&backend aliases list
 aliases = dict(aliases)
 qt_aliases = dict(
     style = 'IPythonWidget.syntax_style',
     stylesheet = 'IPythonQtConsoleApp.stylesheet',
     colors = 'ZMQInteractiveShell.colors',
 
     editor = 'IPythonWidget.editor',
     paging = 'ConsoleWidget.paging',
 )
 # and app_aliases from the Console Mixin
 qt_aliases.update(app_aliases)
 qt_aliases.update({'gui-completion':'ConsoleWidget.gui_completion'})
 # add frontend aliases to the full set
 aliases.update(qt_aliases)
 
 # get flags&aliases into sets, and remove a couple that
 # shouldn't be scrubbed from backend flags:
 qt_aliases = set(qt_aliases.keys())
 qt_aliases.remove('colors')
 qt_flags = set(qt_flags.keys())
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # IPythonQtConsole
 #-----------------------------------------------------------------------------
 
 
 class IPythonQtConsoleApp(BaseIPythonApplication, IPythonConsoleApp):
     name = 'ipython-qtconsole'
 
     description = """
         The IPython QtConsole.
         
         This launches a Console-style application using Qt.  It is not a full
         console, in that launched terminal subprocesses will not be able to accept
         input.
         
         The QtConsole supports various extra features beyond the Terminal IPython
         shell, such as inline plotting with matplotlib, via:
         
             ipython qtconsole --pylab=inline
         
         as well as saving your session as HTML, and printing the output.
         
     """
     examples = _examples
 
     classes = [IPythonWidget] + IPythonConsoleApp.classes
     flags = Dict(flags)
     aliases = Dict(aliases)
     frontend_flags = Any(qt_flags)
     frontend_aliases = Any(qt_aliases)
     kernel_client_class = QtKernelClient
     kernel_manager_class = QtKernelManager
 
     stylesheet = Unicode('', config=True,
         help="path to a custom CSS stylesheet")
 
     hide_menubar = CBool(False, config=True,
         help="Start the console window with the menu bar hidden.")
 
     maximize = CBool(False, config=True,
         help="Start the console window maximized.")
 
     plain = CBool(False, config=True,
         help="Use a plaintext widget instead of rich text (plain can't print/save).")
 
     def _plain_changed(self, name, old, new):
         kind = 'plain' if new else 'rich'
         self.config.ConsoleWidget.kind = kind
         if new:
             self.widget_factory = IPythonWidget
         else:
             self.widget_factory = RichIPythonWidget
 
     # the factory for creating a widget
     widget_factory = Any(RichIPythonWidget)
 
     def parse_command_line(self, argv=None):
         super(IPythonQtConsoleApp, self).parse_command_line(argv)
         self.build_kernel_argv(argv)
 
 
     def new_frontend_master(self):
         """ Create and return new frontend attached to new kernel, launched on localhost.
         """
         kernel_manager = self.kernel_manager_class(
                                 connection_file=self._new_connection_file(),
                                 config=self.config,
                                 autorestart=True,
         )
         # start the kernel
         kwargs = dict()
         kwargs['extra_arguments'] = self.kernel_argv
         kernel_manager.start_kernel(**kwargs)
         kernel_manager.client_factory = self.kernel_client_class
         kernel_client = kernel_manager.client()
         kernel_client.start_channels(shell=True, iopub=True)
         widget = self.widget_factory(config=self.config,
                                    local_kernel=True)
         self.init_colors(widget)
         widget.kernel_manager = kernel_manager
         widget.kernel_client = kernel_client
         widget._existing = False
         widget._may_close = True
         widget._confirm_exit = self.confirm_exit
         return widget
 
     def new_frontend_slave(self, current_widget):
         """Create and return a new frontend attached to an existing kernel.
         
         Parameters
         ----------
         current_widget : IPythonWidget
             The IPythonWidget whose kernel this frontend is to share
         """
         kernel_client = self.kernel_client_class(
                                 connection_file=current_widget.kernel_client.connection_file,
                                 config = self.config,
         )
         kernel_client.load_connection_file()
         kernel_client.start_channels()
         widget = self.widget_factory(config=self.config,
                                 local_kernel=False)
         self.init_colors(widget)
         widget._existing = True
         widget._may_close = False
         widget._confirm_exit = False
         widget.kernel_client = kernel_client
         widget.kernel_manager = current_widget.kernel_manager
         return widget
 
     def init_qt_app(self):
         # separate from qt_elements, because it must run first
         self.app = QtGui.QApplication([])
 
     def init_qt_elements(self):
         # Create the widget.
 
         base_path = os.path.abspath(os.path.dirname(__file__))
         icon_path = os.path.join(base_path, 'resources', 'icon', 'IPythonConsole.svg')
         self.app.icon = QtGui.QIcon(icon_path)
         QtGui.QApplication.setWindowIcon(self.app.icon)
 
         try:
             ip = self.config.KernelManager.ip
         except AttributeError:
             ip = LOCALHOST
         local_kernel = (not self.existing) or ip in LOCAL_IPS
         self.widget = self.widget_factory(config=self.config,
                                         local_kernel=local_kernel)
         self.init_colors(self.widget)
         self.widget._existing = self.existing
         self.widget._may_close = not self.existing
         self.widget._confirm_exit = self.confirm_exit
 
         self.widget.kernel_manager = self.kernel_manager
         self.widget.kernel_client = self.kernel_client
         self.window = MainWindow(self.app,
                                 confirm_exit=self.confirm_exit,
                                 new_frontend_factory=self.new_frontend_master,
                                 slave_frontend_factory=self.new_frontend_slave,
                                 )
         self.window.log = self.log
         self.window.add_tab_with_frontend(self.widget)
         self.window.init_menu_bar()
 
         # Ignore on OSX, where there is always a menu bar
         if sys.platform != 'darwin' and self.hide_menubar:
             self.window.menuBar().setVisible(False)
 
         self.window.setWindowTitle('IPython')
 
     def init_colors(self, widget):
         """Configure the coloring of the widget"""
         # Note: This will be dramatically simplified when colors
         # are removed from the backend.
 
         # parse the colors arg down to current known labels
         try:
             colors = self.config.ZMQInteractiveShell.colors
         except AttributeError:
             colors = None
         try:
             style = self.config.IPythonWidget.syntax_style
         except AttributeError:
             style = None
         try:
             sheet = self.config.IPythonWidget.style_sheet
         except AttributeError:
             sheet = None
 
         # find the value for colors:
         if colors:
             colors=colors.lower()
             if colors in ('lightbg', 'light'):
                 colors='lightbg'
             elif colors in ('dark', 'linux'):
                 colors='linux'
             else:
                 colors='nocolor'
         elif style:
             if style=='bw':
                 colors='nocolor'
             elif styles.dark_style(style):
                 colors='linux'
             else:
                 colors='lightbg'
         else:
             colors=None
 
         # Configure the style
         if style:
             widget.style_sheet = styles.sheet_from_template(style, colors)
             widget.syntax_style = style
             widget._syntax_style_changed()
             widget._style_sheet_changed()
         elif colors:
             # use a default dark/light/bw style
             widget.set_default_style(colors=colors)
 
         if self.stylesheet:
             # we got an explicit stylesheet
             if os.path.isfile(self.stylesheet):
                 with open(self.stylesheet) as f:
                     sheet = f.read()
             else:
                 raise IOError("Stylesheet %r not found." % self.stylesheet)
         if sheet:
             widget.style_sheet = sheet
             widget._style_sheet_changed()
             
 
     def init_signal(self):
         """allow clean shutdown on sigint"""
         signal.signal(signal.SIGINT, lambda sig, frame: self.exit(-2))
         # need a timer, so that QApplication doesn't block until a real
         # Qt event fires (can require mouse movement)
         # timer trick from http://stackoverflow.com/q/4938723/938949
         timer = QtCore.QTimer()
          # Let the interpreter run each 200 ms:
         timer.timeout.connect(lambda: None)
         timer.start(200)
         # hold onto ref, so the timer doesn't get cleaned up
         self._sigint_timer = timer
 
     @catch_config_error
     def initialize(self, argv=None):
         self.init_qt_app()
         super(IPythonQtConsoleApp, self).initialize(argv)
         IPythonConsoleApp.initialize(self,argv)
         self.init_qt_elements()
         self.init_signal()
 
     def start(self):
 
         # draw the window
         if self.maximize:
             self.window.showMaximized()
         else:
             self.window.show()
         self.window.raise_()
 
         # Start the application main loop.
         self.app.exec_()
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 def main():
     app = IPythonQtConsoleApp()
     app.initialize()
     app.start()
 
 
 if __name__ == '__main__':
     main()

IPython/qt/console/rich_ipython_widget.py

@@ -1,325 +1,325 b''
 #-----------------------------------------------------------------------------
 # Copyright (c) 2010, 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.
 #-----------------------------------------------------------------------------
 
 # Standard libary imports.
 from base64 import decodestring
 import os
 import re
 
 # System libary imports.
 from IPython.external.qt import QtCore, QtGui
 
 # Local imports
 from IPython.utils.traitlets import Bool
-from IPython.frontend.qt.svg import save_svg, svg_to_clipboard, svg_to_image
+from IPython.qt.svg import save_svg, svg_to_clipboard, svg_to_image
 from ipython_widget import IPythonWidget
 
 
 class RichIPythonWidget(IPythonWidget):
     """ An IPythonWidget that supports rich text, including lists, images, and
         tables. Note that raw performance will be reduced compared to the plain
         text version.
     """
 
     # RichIPythonWidget protected class variables.
     _payload_source_plot = 'IPython.kernel.zmq.pylab.backend_payload.add_plot_payload'
     _jpg_supported = Bool(False)
 
     # Used to determine whether a given html export attempt has already
     # displayed a warning about being unable to convert a png to svg.
     _svg_warning_displayed = False
 
     #---------------------------------------------------------------------------
     # 'object' interface
     #---------------------------------------------------------------------------
 
     def __init__(self, *args, **kw):
         """ Create a RichIPythonWidget.
         """
         kw['kind'] = 'rich'
         super(RichIPythonWidget, self).__init__(*args, **kw)
 
         # Configure the ConsoleWidget HTML exporter for our formats.
         self._html_exporter.image_tag = self._get_image_tag
 
         # Dictionary for resolving document resource names to SVG data.
         self._name_to_svg_map = {}
 
         # Do we support jpg ?
         # it seems that sometime jpg support is a plugin of QT, so try to assume
         # it is not always supported.
         _supported_format = map(str, QtGui.QImageReader.supportedImageFormats())
         self._jpg_supported = 'jpeg' in _supported_format
 
 
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' public interface overides
     #---------------------------------------------------------------------------
 
     def export_html(self):
         """ Shows a dialog to export HTML/XML in various formats.
 
         Overridden in order to reset the _svg_warning_displayed flag prior
         to the export running.
         """
         self._svg_warning_displayed = False
         super(RichIPythonWidget, self).export_html()
 
 
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' protected interface
     #---------------------------------------------------------------------------
 
     def _context_menu_make(self, pos):
         """ Reimplemented to return a custom context menu for images.
         """
         format = self._control.cursorForPosition(pos).charFormat()
         name = format.stringProperty(QtGui.QTextFormat.ImageName)
         if name:
             menu = QtGui.QMenu()
 
             menu.addAction('Copy Image', lambda: self._copy_image(name))
             menu.addAction('Save Image As...', lambda: self._save_image(name))
             menu.addSeparator()
 
             svg = self._name_to_svg_map.get(name, None)
             if svg is not None:
                 menu.addSeparator()
                 menu.addAction('Copy SVG', lambda: svg_to_clipboard(svg))
                 menu.addAction('Save SVG As...',
                                lambda: save_svg(svg, self._control))
         else:
             menu = super(RichIPythonWidget, self)._context_menu_make(pos)
         return menu
 
     #---------------------------------------------------------------------------
     # 'BaseFrontendMixin' abstract interface
     #---------------------------------------------------------------------------
     def _pre_image_append(self, msg, prompt_number):
         """ Append the Out[] prompt  and make the output nicer
 
         Shared code for some the following if statement
         """
         self.log.debug("pyout: %s", msg.get('content', ''))
         self._append_plain_text(self.output_sep, True)
         self._append_html(self._make_out_prompt(prompt_number), True)
         self._append_plain_text('\n', True)
 
     def _handle_pyout(self, msg):
         """ Overridden to handle rich data types, like SVG.
         """
         if not self._hidden and self._is_from_this_session(msg):
             content = msg['content']
             prompt_number = content.get('execution_count', 0)
             data = content['data']
             if 'image/svg+xml' in data:
                 self._pre_image_append(msg, prompt_number)
                 self._append_svg(data['image/svg+xml'], True)
                 self._append_html(self.output_sep2, True)
             elif 'image/png' in data:
                 self._pre_image_append(msg, prompt_number)
                 self._append_png(decodestring(data['image/png'].encode('ascii')), True)
                 self._append_html(self.output_sep2, True)
             elif 'image/jpeg' in data and self._jpg_supported:
                 self._pre_image_append(msg, prompt_number)
                 self._append_jpg(decodestring(data['image/jpeg'].encode('ascii')), True)
                 self._append_html(self.output_sep2, True)
             else:
                 # Default back to the plain text representation.
                 return super(RichIPythonWidget, self)._handle_pyout(msg)
 
     def _handle_display_data(self, msg):
         """ Overridden to handle rich data types, like SVG.
         """
         if not self._hidden and self._is_from_this_session(msg):
             source = msg['content']['source']
             data = msg['content']['data']
             metadata = msg['content']['metadata']
             # Try to use the svg or html representations.
             # FIXME: Is this the right ordering of things to try?
             if 'image/svg+xml' in data:
                 self.log.debug("display: %s", msg.get('content', ''))
                 svg = data['image/svg+xml']
                 self._append_svg(svg, True)
             elif 'image/png' in data:
                 self.log.debug("display: %s", msg.get('content', ''))
                 # PNG data is base64 encoded as it passes over the network
                 # in a JSON structure so we decode it.
                 png = decodestring(data['image/png'].encode('ascii'))
                 self._append_png(png, True)
             elif 'image/jpeg' in data and self._jpg_supported:
                 self.log.debug("display: %s", msg.get('content', ''))
                 jpg = decodestring(data['image/jpeg'].encode('ascii'))
                 self._append_jpg(jpg, True)
             else:
                 # Default back to the plain text representation.
                 return super(RichIPythonWidget, self)._handle_display_data(msg)
 
     #---------------------------------------------------------------------------
     # 'RichIPythonWidget' protected interface
     #---------------------------------------------------------------------------
 
     def _append_jpg(self, jpg, before_prompt=False):
         """ Append raw JPG data to the widget."""
         self._append_custom(self._insert_jpg, jpg, before_prompt)
 
     def _append_png(self, png, before_prompt=False):
         """ Append raw PNG data to the widget.
         """
         self._append_custom(self._insert_png, png, before_prompt)
 
     def _append_svg(self, svg, before_prompt=False):
         """ Append raw SVG data to the widget.
         """
         self._append_custom(self._insert_svg, svg, before_prompt)
 
     def _add_image(self, image):
         """ Adds the specified QImage to the document and returns a
             QTextImageFormat that references it.
         """
         document = self._control.document()
         name = str(image.cacheKey())
         document.addResource(QtGui.QTextDocument.ImageResource,
                              QtCore.QUrl(name), image)
         format = QtGui.QTextImageFormat()
         format.setName(name)
         return format
 
     def _copy_image(self, name):
         """ Copies the ImageResource with 'name' to the clipboard.
         """
         image = self._get_image(name)
         QtGui.QApplication.clipboard().setImage(image)
 
     def _get_image(self, name):
         """ Returns the QImage stored as the ImageResource with 'name'.
         """
         document = self._control.document()
         image = document.resource(QtGui.QTextDocument.ImageResource,
                                   QtCore.QUrl(name))
         return image
 
     def _get_image_tag(self, match, path = None, format = "png"):
         """ Return (X)HTML mark-up for the image-tag given by match.
 
         Parameters
         ----------
         match : re.SRE_Match
             A match to an HTML image tag as exported by Qt, with
             match.group("Name") containing the matched image ID.
 
         path : string|None, optional [default None]
             If not None, specifies a path to which supporting files may be
             written (e.g., for linked images).  If None, all images are to be
             included inline.
 
         format : "png"|"svg"|"jpg", optional [default "png"]
             Format for returned or referenced images.
         """
         if format in ("png","jpg"):
             try:
                 image = self._get_image(match.group("name"))
             except KeyError:
                 return "<b>Couldn't find image %s</b>" % match.group("name")
 
             if path is not None:
                 if not os.path.exists(path):
                     os.mkdir(path)
                 relpath = os.path.basename(path)
                 if image.save("%s/qt_img%s.%s" % (path, match.group("name"), format),
                               "PNG"):
                     return '<img src="%s/qt_img%s.%s">' % (relpath,
                                                             match.group("name"),format)
                 else:
                     return "<b>Couldn't save image!</b>"
             else:
                 ba = QtCore.QByteArray()
                 buffer_ = QtCore.QBuffer(ba)
                 buffer_.open(QtCore.QIODevice.WriteOnly)
                 image.save(buffer_, format.upper())
                 buffer_.close()
                 return '<img src="data:image/%s;base64,\n%s\n" />' % (
                     format,re.sub(r'(.{60})',r'\1\n',str(ba.toBase64())))
 
         elif format == "svg":
             try:
                 svg = str(self._name_to_svg_map[match.group("name")])
             except KeyError:
                 if not self._svg_warning_displayed:
                     QtGui.QMessageBox.warning(self, 'Error converting PNG to SVG.',
                         'Cannot convert a PNG to SVG.  To fix this, add this '
                         'to your ipython config:\n\n'
                         '\tc.InlineBackendConfig.figure_format = \'svg\'\n\n'
                         'And regenerate the figures.',
                                               QtGui.QMessageBox.Ok)
                     self._svg_warning_displayed = True
                 return ("<b>Cannot convert a PNG to SVG.</b>  "
                         "To fix this, add this to your config: "
                         "<span>c.InlineBackendConfig.figure_format = 'svg'</span> "
                         "and regenerate the figures.")
 
             # Not currently checking path, because it's tricky to find a
             # cross-browser way to embed external SVG images (e.g., via
             # object or embed tags).
 
             # Chop stand-alone header from matplotlib SVG
             offset = svg.find("<svg")
             assert(offset > -1)
 
             return svg[offset:]
 
         else:
             return '<b>Unrecognized image format</b>'
 
     def _insert_jpg(self, cursor, jpg):
         """ Insert raw PNG data into the widget."""
         self._insert_img(cursor, jpg, 'jpg')
 
     def _insert_png(self, cursor, png):
         """ Insert raw PNG data into the widget.
         """
         self._insert_img(cursor, png, 'png')
 
     def _insert_img(self, cursor, img, fmt):
         """ insert a raw image, jpg or png """
         try:
             image = QtGui.QImage()
             image.loadFromData(img, fmt.upper())
         except ValueError:
             self._insert_plain_text(cursor, 'Received invalid %s data.'%fmt)
         else:
             format = self._add_image(image)
             cursor.insertBlock()
             cursor.insertImage(format)
             cursor.insertBlock()
 
     def _insert_svg(self, cursor, svg):
         """ Insert raw SVG data into the widet.
         """
         try:
             image = svg_to_image(svg)
         except ValueError:
             self._insert_plain_text(cursor, 'Received invalid SVG data.')
         else:
             format = self._add_image(image)
             self._name_to_svg_map[format.name()] = svg
             cursor.insertBlock()
             cursor.insertImage(format)
             cursor.insertBlock()
 
     def _save_image(self, name, format='PNG'):
         """ Shows a save dialog for the ImageResource with 'name'.
         """
         dialog = QtGui.QFileDialog(self._control, 'Save Image')
         dialog.setAcceptMode(QtGui.QFileDialog.AcceptSave)
         dialog.setDefaultSuffix(format.lower())
         dialog.setNameFilter('%s file (*.%s)' % (format, format.lower()))
         if dialog.exec_():
             filename = dialog.selectedFiles()[0]
             image = self._get_image(name)
             image.save(filename, format)

IPython/qt/console/tests/test_ansi_code_processor.py

@@ -1,171 +1,171 b''
 # Standard library imports
 import unittest
 
 # Local imports
-from IPython.frontend.qt.console.ansi_code_processor import AnsiCodeProcessor
+from IPython.qt.console.ansi_code_processor import AnsiCodeProcessor
 
 
 class TestAnsiCodeProcessor(unittest.TestCase):
 
     def setUp(self):
         self.processor = AnsiCodeProcessor()
 
     def test_clear(self):
         """ Do control sequences for clearing the console work?
         """
         string = '\x1b[2J\x1b[K'
         i = -1
         for i, substring in enumerate(self.processor.split_string(string)):
             if i == 0:
                 self.assertEqual(len(self.processor.actions), 1)
                 action = self.processor.actions[0]
                 self.assertEqual(action.action, 'erase')
                 self.assertEqual(action.area, 'screen')
                 self.assertEqual(action.erase_to, 'all')
             elif i == 1:
                 self.assertEqual(len(self.processor.actions), 1)
                 action = self.processor.actions[0]
                 self.assertEqual(action.action, 'erase')
                 self.assertEqual(action.area, 'line')
                 self.assertEqual(action.erase_to, 'end')
             else:
                 self.fail('Too many substrings.')
         self.assertEqual(i, 1, 'Too few substrings.')
 
     def test_colors(self):
         """ Do basic controls sequences for colors work?
         """
         string = 'first\x1b[34mblue\x1b[0mlast'
         i = -1
         for i, substring in enumerate(self.processor.split_string(string)):
             if i == 0:
                 self.assertEqual(substring, 'first')
                 self.assertEqual(self.processor.foreground_color, None)
             elif i == 1:
                 self.assertEqual(substring, 'blue')
                 self.assertEqual(self.processor.foreground_color, 4)
             elif i == 2:
                 self.assertEqual(substring, 'last')
                 self.assertEqual(self.processor.foreground_color, None)
             else:
                 self.fail('Too many substrings.')
         self.assertEqual(i, 2, 'Too few substrings.')
 
     def test_colors_xterm(self):
         """ Do xterm-specific control sequences for colors work?
         """
         string = '\x1b]4;20;rgb:ff/ff/ff\x1b' \
             '\x1b]4;25;rgbi:1.0/1.0/1.0\x1b'
         substrings = list(self.processor.split_string(string))
         desired = { 20 : (255, 255, 255),
                     25 : (255, 255, 255) }
         self.assertEqual(self.processor.color_map, desired)
 
         string = '\x1b[38;5;20m\x1b[48;5;25m'
         substrings = list(self.processor.split_string(string))
         self.assertEqual(self.processor.foreground_color, 20)
         self.assertEqual(self.processor.background_color, 25)
 
     def test_scroll(self):
         """ Do control sequences for scrolling the buffer work?
         """
         string = '\x1b[5S\x1b[T'
         i = -1
         for i, substring in enumerate(self.processor.split_string(string)):
             if i == 0:
                 self.assertEqual(len(self.processor.actions), 1)
                 action = self.processor.actions[0]
                 self.assertEqual(action.action, 'scroll')
                 self.assertEqual(action.dir, 'up')
                 self.assertEqual(action.unit, 'line')
                 self.assertEqual(action.count, 5)
             elif i == 1:
                 self.assertEqual(len(self.processor.actions), 1)
                 action = self.processor.actions[0]
                 self.assertEqual(action.action, 'scroll')
                 self.assertEqual(action.dir, 'down')
                 self.assertEqual(action.unit, 'line')
                 self.assertEqual(action.count, 1)
             else:
                 self.fail('Too many substrings.')
         self.assertEqual(i, 1, 'Too few substrings.')
 
     def test_formfeed(self):
         """ Are formfeed characters processed correctly?
         """
         string = '\f' # form feed
         self.assertEqual(list(self.processor.split_string(string)), [''])
         self.assertEqual(len(self.processor.actions), 1)
         action = self.processor.actions[0]
         self.assertEqual(action.action, 'scroll')
         self.assertEqual(action.dir, 'down')
         self.assertEqual(action.unit, 'page')
         self.assertEqual(action.count, 1)
 
     def test_carriage_return(self):
         """ Are carriage return characters processed correctly?
         """
         string = 'foo\rbar' # carriage return
         splits = []
         actions = []
         for split in self.processor.split_string(string):
             splits.append(split)
             actions.append([action.action for action in self.processor.actions])
         self.assertEqual(splits, ['foo', None, 'bar'])
         self.assertEqual(actions, [[], ['carriage-return'], []])
 
     def test_carriage_return_newline(self):
         """transform CRLF to LF"""
         string = 'foo\rbar\r\ncat\r\n\n' # carriage return and newline
         # only one CR action should occur, and '\r\n' should transform to '\n'
         splits = []
         actions = []
         for split in self.processor.split_string(string):
             splits.append(split)
             actions.append([action.action for action in self.processor.actions])
         self.assertEqual(splits, ['foo', None, 'bar', '\r\n', 'cat', '\r\n', '\n'])
         self.assertEqual(actions, [[], ['carriage-return'], [], ['newline'], [], ['newline'], ['newline']])
 
     def test_beep(self):
         """ Are beep characters processed correctly?
         """
         string = 'foo\abar' # bell
         splits = []
         actions = []
         for split in self.processor.split_string(string):
             splits.append(split)
             actions.append([action.action for action in self.processor.actions])
         self.assertEqual(splits, ['foo', None, 'bar'])
         self.assertEqual(actions, [[], ['beep'], []])
 
     def test_backspace(self):
         """ Are backspace characters processed correctly?
         """
         string = 'foo\bbar' # backspace
         splits = []
         actions = []
         for split in self.processor.split_string(string):
             splits.append(split)
             actions.append([action.action for action in self.processor.actions])
         self.assertEqual(splits, ['foo', None, 'bar'])
         self.assertEqual(actions, [[], ['backspace'], []])
 
     def test_combined(self):
         """ Are CR and BS characters processed correctly in combination?
 
         BS is treated as a change in print position, rather than a
         backwards character deletion.  Therefore a BS at EOL is
         effectively ignored.
         """
         string = 'abc\rdef\b' # CR and backspace
         splits = []
         actions = []
         for split in self.processor.split_string(string):
             splits.append(split)
             actions.append([action.action for action in self.processor.actions])
         self.assertEqual(splits, ['abc', None, 'def', None])
         self.assertEqual(actions, [[], ['carriage-return'], [], ['backspace']])
 
 
 if __name__ == '__main__':
     unittest.main()

IPython/qt/console/tests/test_completion_lexer.py

@@ -1,47 +1,47 b''
 # Standard library imports
 import unittest
 
 # System library imports
 from pygments.lexers import CLexer, CppLexer, PythonLexer
 
 # Local imports
-from IPython.frontend.qt.console.completion_lexer import CompletionLexer
+from IPython.qt.console.completion_lexer import CompletionLexer
 
 
 class TestCompletionLexer(unittest.TestCase):
     
     def testPython(self):
         """ Does the CompletionLexer work for Python?
         """
         lexer = CompletionLexer(PythonLexer())
 
         # Test simplest case.
         self.assertEqual(lexer.get_context("foo.bar.baz"),
                           [ "foo", "bar", "baz" ])
 
         # Test trailing period.
         self.assertEqual(lexer.get_context("foo.bar."), [ "foo", "bar", "" ])
 
         # Test with prompt present.
         self.assertEqual(lexer.get_context(">>> foo.bar.baz"),
                           [ "foo", "bar", "baz" ])
 
         # Test spacing in name.
         self.assertEqual(lexer.get_context("foo.bar. baz"), [ "baz" ])
 
         # Test parenthesis.
         self.assertEqual(lexer.get_context("foo("), [])
 
     def testC(self):
         """ Does the CompletionLexer work for C/C++?
         """
         lexer = CompletionLexer(CLexer())
         self.assertEqual(lexer.get_context("foo.bar"), [ "foo", "bar" ])
         self.assertEqual(lexer.get_context("foo->bar"), [ "foo", "bar" ])
 
         lexer = CompletionLexer(CppLexer())
         self.assertEqual(lexer.get_context("Foo::Bar"), [ "Foo", "Bar" ])
 
 
 if __name__ == '__main__':
     unittest.main()

IPython/qt/console/tests/test_console_widget.py

@@ -1,80 +1,80 b''
 # Standard library imports
 import unittest
 
 # System library imports
 from IPython.external.qt import QtCore, QtGui
 
 # Local imports
-from IPython.frontend.qt.console.console_widget import ConsoleWidget
+from IPython.qt.console.console_widget import ConsoleWidget
 
 
 class TestConsoleWidget(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
         """ Create the application for the test case.
         """
         cls._app = QtGui.QApplication.instance()
         if cls._app is None:
             cls._app = QtGui.QApplication([])
         cls._app.setQuitOnLastWindowClosed(False)
 
     @classmethod
     def tearDownClass(cls):
         """ Exit the application.
         """
         QtGui.QApplication.quit()
 
     def test_special_characters(self):
         """ Are special characters displayed correctly?
         """
         w = ConsoleWidget()
         cursor = w._get_prompt_cursor()
 
         test_inputs = ['xyz\b\b=\n', 'foo\b\nbar\n', 'foo\b\nbar\r\n', 'abc\rxyz\b\b=']
         expected_outputs = [u'x=z\u2029', u'foo\u2029bar\u2029', u'foo\u2029bar\u2029', 'x=z']
         for i, text in enumerate(test_inputs):
             w._insert_plain_text(cursor, text)
             cursor.select(cursor.Document)
             selection = cursor.selectedText()
             self.assertEqual(expected_outputs[i], selection)
             # clear all the text
             cursor.insertText('')
 
     def test_link_handling(self):
         noKeys = QtCore.Qt
         noButton = QtCore.Qt.MouseButton(0)
         noButtons = QtCore.Qt.MouseButtons(0)
         noModifiers = QtCore.Qt.KeyboardModifiers(0)
         MouseMove = QtCore.QEvent.MouseMove
         QMouseEvent = QtGui.QMouseEvent
         
         w = ConsoleWidget()
         cursor = w._get_prompt_cursor()
         w._insert_html(cursor, '<a href="http://python.org">written in</a>')
         obj = w._control
         tip = QtGui.QToolTip
         self.assertEqual(tip.text(), u'')
         
         # should be somewhere else
         elsewhereEvent = QMouseEvent(MouseMove, QtCore.QPoint(50,50),
                                      noButton, noButtons, noModifiers)
         w.eventFilter(obj, elsewhereEvent)
         self.assertEqual(tip.isVisible(), False)
         self.assertEqual(tip.text(), u'')
         
         #self.assertEqual(tip.text(), u'')
         # should be over text
         overTextEvent = QMouseEvent(MouseMove, QtCore.QPoint(1,5),
                                     noButton, noButtons, noModifiers)
         w.eventFilter(obj, overTextEvent)
         self.assertEqual(tip.isVisible(), True)
         self.assertEqual(tip.text(), "http://python.org")
         
         # should still be over text
         stillOverTextEvent = QMouseEvent(MouseMove, QtCore.QPoint(1,5),
                                          noButton, noButtons, noModifiers)
         w.eventFilter(obj, stillOverTextEvent)
         self.assertEqual(tip.isVisible(), True)
         self.assertEqual(tip.text(), "http://python.org")
         

IPython/qt/console/tests/test_kill_ring.py

@@ -1,85 +1,85 b''
 # Standard library imports
 import unittest
 
 # System library imports
 from IPython.external.qt import QtCore, QtGui
 
 # Local imports
-from IPython.frontend.qt.console.kill_ring import KillRing, QtKillRing
+from IPython.qt.console.kill_ring import KillRing, QtKillRing
 
 
 class TestKillRing(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
         """ Create the application for the test case.
         """
         cls._app = QtGui.QApplication.instance()
         if cls._app is None:
             cls._app = QtGui.QApplication([])
         cls._app.setQuitOnLastWindowClosed(False)
 
     @classmethod
     def tearDownClass(cls):
         """ Exit the application.
         """
         QtGui.QApplication.quit()
 
     def test_generic(self):
         """ Does the generic kill ring work?
         """
         ring = KillRing()
         self.assertTrue(ring.yank() is None)
         self.assertTrue(ring.rotate() is None)
 
         ring.kill('foo')
         self.assertEqual(ring.yank(), 'foo')
         self.assertTrue(ring.rotate() is None)
         self.assertEqual(ring.yank(), 'foo')
 
         ring.kill('bar')
         self.assertEqual(ring.yank(), 'bar')
         self.assertEqual(ring.rotate(), 'foo')
 
         ring.clear()
         self.assertTrue(ring.yank() is None)
         self.assertTrue(ring.rotate() is None)
 
     def test_qt_basic(self):
         """ Does the Qt kill ring work?
         """
         text_edit = QtGui.QPlainTextEdit()
         ring = QtKillRing(text_edit)
 
         ring.kill('foo')
         ring.kill('bar')
         ring.yank()
         ring.rotate()
         ring.yank()
         self.assertEqual(text_edit.toPlainText(), 'foobar')
 
         text_edit.clear()
         ring.kill('baz')
         ring.yank()
         ring.rotate()
         ring.rotate()
         ring.rotate()
         self.assertEqual(text_edit.toPlainText(), 'foo')
 
     def test_qt_cursor(self):
         """ Does the Qt kill ring maintain state with cursor movement?
         """
         text_edit = QtGui.QPlainTextEdit()
         ring = QtKillRing(text_edit)
         
         ring.kill('foo')
         ring.kill('bar')
         ring.yank()
         text_edit.moveCursor(QtGui.QTextCursor.Left)
         ring.rotate()
         self.assertEqual(text_edit.toPlainText(), 'bar')
 
 
 if __name__ == '__main__':
     import nose
     nose.main()

IPython/scripts/ipython

@@ -1,7 +1,7 b''
 #!/usr/bin/env python
 """Terminal-based IPython entry point.
 """
 
-from IPython.frontend.terminal.ipapp import launch_new_instance
+from IPython.terminal.ipapp import launch_new_instance
 
 launch_new_instance()

IPython/terminal/console/app.py

@@ -1,157 +1,157 b''
 """ A minimal application using the ZMQ-based terminal IPython frontend.
 
 This is not a complete console app, as subprocess will not be able to receive
 input, there is no real readline support, among other limitations.
 
 Authors:
 
 * Min RK
 * Paul Ivanov
 
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 import signal
 import sys
 import time
 
-from IPython.frontend.terminal.ipapp import TerminalIPythonApp, frontend_flags as term_flags
+from IPython.terminal.ipapp import TerminalIPythonApp, frontend_flags as term_flags
 
 from IPython.utils.traitlets import (
     Dict, List, Unicode, Int, CaselessStrEnum, CBool, Any
 )
 from IPython.utils.warn import warn,error
 
 from IPython.kernel.zmq.kernelapp import IPKernelApp
 from IPython.kernel.zmq.session import Session, default_secure
 from IPython.kernel.zmq.zmqshell import ZMQInteractiveShell
-from IPython.frontend.consoleapp import (
+from IPython.consoleapp import (
         IPythonConsoleApp, app_aliases, app_flags, aliases, app_aliases, flags
     )
 
-from IPython.frontend.terminal.console.interactiveshell import ZMQTerminalInteractiveShell
+from IPython.terminal.console.interactiveshell import ZMQTerminalInteractiveShell
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 _examples = """
 ipython console # start the ZMQ-based console
 ipython console --existing # connect to an existing ipython session
 """
 
 #-----------------------------------------------------------------------------
 # Flags and Aliases
 #-----------------------------------------------------------------------------
 
 # copy flags from mixin:
 flags = dict(flags)
 # start with mixin frontend flags:
 frontend_flags = dict(app_flags)
 # add TerminalIPApp flags:
 frontend_flags.update(term_flags)
 # disable quick startup, as it won't propagate to the kernel anyway
 frontend_flags.pop('quick')
 # update full dict with frontend flags:
 flags.update(frontend_flags)
 
 # copy flags from mixin
 aliases = dict(aliases)
 # start with mixin frontend flags
 frontend_aliases = dict(app_aliases)
 # load updated frontend flags into full dict
 aliases.update(frontend_aliases)
 
 # get flags&aliases into sets, and remove a couple that
 # shouldn't be scrubbed from backend flags:
 frontend_aliases = set(frontend_aliases.keys())
 frontend_flags = set(frontend_flags.keys())
 
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 
 class ZMQTerminalIPythonApp(TerminalIPythonApp, IPythonConsoleApp):
     name = "ipython-console"
     """Start a terminal frontend to the IPython zmq kernel."""
 
     description = """
         The IPython terminal-based Console.
 
         This launches a Console application inside a terminal.
 
         The Console supports various extra features beyond the traditional
         single-process Terminal IPython shell, such as connecting to an
         existing ipython session, via:
 
             ipython console --existing
 
         where the previous session could have been created by another ipython
         console, an ipython qtconsole, or by opening an ipython notebook.
 
     """
     examples = _examples
 
     classes = [ZMQTerminalInteractiveShell] + IPythonConsoleApp.classes
     flags = Dict(flags)
     aliases = Dict(aliases)
     frontend_aliases = Any(frontend_aliases)
     frontend_flags = Any(frontend_flags)
     
     subcommands = Dict()
 
     def parse_command_line(self, argv=None):
         super(ZMQTerminalIPythonApp, self).parse_command_line(argv)
         self.build_kernel_argv(argv)
 
     def init_shell(self):
         IPythonConsoleApp.initialize(self)
         # relay sigint to kernel
         signal.signal(signal.SIGINT, self.handle_sigint)
         self.shell = ZMQTerminalInteractiveShell.instance(config=self.config,
                         display_banner=False, profile_dir=self.profile_dir,
                         ipython_dir=self.ipython_dir,
                         manager=self.kernel_manager,
                         client=self.kernel_client,
         )
 
     def init_gui_pylab(self):
         # no-op, because we don't want to import matplotlib in the frontend.
         pass
 
     def handle_sigint(self, *args):
         if self.shell._executing:
             if self.kernel_manager:
                 # interrupt already gets passed to subprocess by signal handler.
                 # Only if we prevent that should we need to explicitly call
                 # interrupt_kernel, until which time, this would result in a 
                 # double-interrupt:
                 # self.kernel_manager.interrupt_kernel()
                 pass
             else:
                 self.shell.write_err('\n')
                 error("Cannot interrupt kernels we didn't start.\n")
         else:
             # raise the KeyboardInterrupt if we aren't waiting for execution,
             # so that the interact loop advances, and prompt is redrawn, etc.
             raise KeyboardInterrupt
             
 
     def init_code(self):
         # no-op in the frontend, code gets run in the backend
         pass
 
 def launch_new_instance():
     """Create and run a full blown IPython instance"""
     app = ZMQTerminalIPythonApp.instance()
     app.initialize()
     app.start()
 
 
 if __name__ == '__main__':
     launch_new_instance()
 

IPython/terminal/console/interactiveshell.py

@@ -1,465 +1,465 b''
 # -*- coding: utf-8 -*-
 """terminal client to the IPython kernel
 
 """
 #-----------------------------------------------------------------------------
 # Copyright (C) 2013 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
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 import bdb
 import signal
 import os
 import sys
 import time
 import subprocess
 from io import BytesIO
 import base64
 
 from Queue import Empty
 
 try:
     from contextlib import nested
 except:
     from IPython.utils.nested_context import nested
 
 from IPython.core.alias import AliasManager, AliasError
 from IPython.core import page
 from IPython.utils.warn import warn, error, fatal
 from IPython.utils import io
 from IPython.utils.traitlets import List, Enum, Any, Instance, Unicode
 from IPython.utils.tempdir import NamedFileInTemporaryDirectory
 
-from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
-from IPython.frontend.terminal.console.completer import ZMQCompleter
+from IPython.terminal.interactiveshell import TerminalInteractiveShell
+from IPython.terminal.console.completer import ZMQCompleter
 
 
 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
     """A subclass of TerminalInteractiveShell that uses the 0MQ kernel"""
     _executing = False
 
     image_handler = Enum(('PIL', 'stream', 'tempfile', 'callable'),
                          config=True, help=
         """
         Handler for image type output.  This is useful, for example,
         when connecting to the kernel in which pylab inline backend is
         activated.  There are four handlers defined.  'PIL': Use
         Python Imaging Library to popup image; 'stream': Use an
         external program to show the image.  Image will be fed into
         the STDIN of the program.  You will need to configure
         `stream_image_handler`; 'tempfile': Use an external program to
         show the image.  Image will be saved in a temporally file and
         the program is called with the temporally file.  You will need
         to configure `tempfile_image_handler`; 'callable': You can set
         any Python callable which is called with the image data.  You
         will need to configure `callable_image_handler`.
         """
     )
 
     stream_image_handler = List(config=True, help=
         """
         Command to invoke an image viewer program when you are using
         'stream' image handler.  This option is a list of string where
         the first element is the command itself and reminders are the
         options for the command.  Raw image data is given as STDIN to
         the program.
         """
     )
 
     tempfile_image_handler = List(config=True, help=
         """
         Command to invoke an image viewer program when you are using
         'tempfile' image handler.  This option is a list of string
         where the first element is the command itself and reminders
         are the options for the command.  You can use {file} and
         {format} in the string to represent the location of the
         generated image file and image format.
         """
     )
 
     callable_image_handler = Any(config=True, help=
         """
         Callable object called via 'callable' image handler with one
         argument, `data`, which is `msg["content"]["data"]` where
         `msg` is the message from iopub channel.  For exmaple, you can
         find base64 encoded PNG data as `data['image/png']`.
         """
     )
 
     mime_preference = List(
         default_value=['image/png', 'image/jpeg', 'image/svg+xml'],
         config=True, allow_none=False, help=
         """
         Preferred object representation MIME type in order.  First
         matched MIME type will be used.
         """
     )
 
     manager = Instance('IPython.kernel.KernelManager')
     client = Instance('IPython.kernel.KernelClient')
     def _client_changed(self, name, old, new):
         self.session_id = new.session.session
     session_id = Unicode()
 
     def init_completer(self):
         """Initialize the completion machinery.
 
         This creates completion machinery that can be used by client code,
         either interactively in-process (typically triggered by the readline
         library), programatically (such as in test suites) or out-of-prcess
         (typically over the network by remote frontends).
         """
         from IPython.core.completerlib import (module_completer,
                                                magic_run_completer, cd_completer)
         
         self.Completer = ZMQCompleter(self, self.client)
         
 
         self.set_hook('complete_command', module_completer, str_key = 'import')
         self.set_hook('complete_command', module_completer, str_key = 'from')
         self.set_hook('complete_command', magic_run_completer, str_key = '%run')
         self.set_hook('complete_command', cd_completer, str_key = '%cd')
 
         # Only configure readline if we truly are using readline.  IPython can
         # do tab-completion over the network, in GUIs, etc, where readline
         # itself may be absent
         if self.has_readline:
             self.set_readline_completer()
     
     def run_cell(self, cell, store_history=True):
         """Run a complete IPython cell.
         
         Parameters
         ----------
         cell : str
           The code (including IPython code such as %magic functions) to run.
         store_history : bool
           If True, the raw and translated cell will be stored in IPython's
           history. For user code calling back into IPython's machinery, this
           should be set to False.
         """
         if (not cell) or cell.isspace():
             return
 
         if cell.strip() == 'exit':
             # explicitly handle 'exit' command
             return self.ask_exit()
 
         self._executing = True
         # flush stale replies, which could have been ignored, due to missed heartbeats
         while self.client.shell_channel.msg_ready():
             self.client.shell_channel.get_msg()
         # shell_channel.execute takes 'hidden', which is the inverse of store_hist
         msg_id = self.client.shell_channel.execute(cell, not store_history)
         while not self.client.shell_channel.msg_ready() and self.client.is_alive():
             try:
                 self.handle_stdin_request(timeout=0.05)
             except Empty:
                 # display intermediate print statements, etc.
                 self.handle_iopub()
                 pass
         if self.client.shell_channel.msg_ready():
             self.handle_execute_reply(msg_id)
         self._executing = False
 
     #-----------------
     # message handlers
     #-----------------
 
     def handle_execute_reply(self, msg_id):
         msg = self.client.shell_channel.get_msg()
         if msg["parent_header"].get("msg_id", None) == msg_id:
             
             self.handle_iopub()
             
             content = msg["content"]
             status = content['status']
             
             if status == 'aborted':
                 self.write('Aborted\n')
                 return
             elif status == 'ok':
                 # print execution payloads as well:
                 for item in content["payload"]:
                     text = item.get('text', None)
                     if text:
                         page.page(text)
                
             elif status == 'error':
                 for frame in content["traceback"]:
                     print(frame, file=io.stderr)
             
             self.execution_count = int(content["execution_count"] + 1)
 
 
     def handle_iopub(self):
         """ Method to procces subscribe channel's messages
 
            This method reads a message and processes the content in different
            outputs like stdout, stderr, pyout and status
 
            Arguments:
            sub_msg:  message receive from kernel in the sub socket channel
                      capture by kernel manager.
         """
         while self.client.iopub_channel.msg_ready():
             sub_msg = self.client.iopub_channel.get_msg()
             msg_type = sub_msg['header']['msg_type']
             parent = sub_msg["parent_header"]
             if (not parent) or self.session_id == parent['session']:
                 if msg_type == 'status' :
                     if sub_msg["content"]["execution_state"] == "busy" :
                         pass
 
                 elif msg_type == 'stream' :
                     if sub_msg["content"]["name"] == "stdout":
                         print(sub_msg["content"]["data"], file=io.stdout, end="")
                         io.stdout.flush()
                     elif sub_msg["content"]["name"] == "stderr" :
                         print(sub_msg["content"]["data"], file=io.stderr, end="")
                         io.stderr.flush()
 
                 elif msg_type == 'pyout':
                     self.execution_count = int(sub_msg["content"]["execution_count"])
                     format_dict = sub_msg["content"]["data"]
                     self.handle_rich_data(format_dict)
                     # taken from DisplayHook.__call__:
                     hook = self.displayhook
                     hook.start_displayhook()
                     hook.write_output_prompt()
                     hook.write_format_data(format_dict)
                     hook.log_output(format_dict)
                     hook.finish_displayhook()
 
                 elif msg_type == 'display_data':
                     self.handle_rich_data(sub_msg["content"]["data"])
 
     _imagemime = {
         'image/png': 'png',
         'image/jpeg': 'jpeg',
         'image/svg+xml': 'svg',
     }
 
     def handle_rich_data(self, data):
         for mime in self.mime_preference:
             if mime in data and mime in self._imagemime:
                 self.handle_image(data, mime)
                 return
 
     def handle_image(self, data, mime):
         handler = getattr(
             self, 'handle_image_{0}'.format(self.image_handler), None)
         if handler:
             handler(data, mime)
 
     def handle_image_PIL(self, data, mime):
         if mime not in ('image/png', 'image/jpeg'):
             return
         import PIL.Image
         raw = base64.decodestring(data[mime].encode('ascii'))
         img = PIL.Image.open(BytesIO(raw))
         img.show()
 
     def handle_image_stream(self, data, mime):
         raw = base64.decodestring(data[mime].encode('ascii'))
         imageformat = self._imagemime[mime]
         fmt = dict(format=imageformat)
         args = [s.format(**fmt) for s in self.stream_image_handler]
         with open(os.devnull, 'w') as devnull:
             proc = subprocess.Popen(
                 args, stdin=subprocess.PIPE,
                 stdout=devnull, stderr=devnull)
             proc.communicate(raw)
 
     def handle_image_tempfile(self, data, mime):
         raw = base64.decodestring(data[mime].encode('ascii'))
         imageformat = self._imagemime[mime]
         filename = 'tmp.{0}'.format(imageformat)
         with nested(NamedFileInTemporaryDirectory(filename),
                     open(os.devnull, 'w')) as (f, devnull):
             f.write(raw)
             f.flush()
             fmt = dict(file=f.name, format=imageformat)
             args = [s.format(**fmt) for s in self.tempfile_image_handler]
             subprocess.call(args, stdout=devnull, stderr=devnull)
 
     def handle_image_callable(self, data, mime):
         self.callable_image_handler(data)
 
     def handle_stdin_request(self, timeout=0.1):
         """ Method to capture raw_input
         """
         msg_rep = self.client.stdin_channel.get_msg(timeout=timeout)
         # in case any iopub came while we were waiting:
         self.handle_iopub()
         if self.session_id == msg_rep["parent_header"].get("session"):
             # wrap SIGINT handler
             real_handler = signal.getsignal(signal.SIGINT)
             def double_int(sig,frame):
                 # call real handler (forwards sigint to kernel),
                 # then raise local interrupt, stopping local raw_input
                 real_handler(sig,frame)
                 raise KeyboardInterrupt
             signal.signal(signal.SIGINT, double_int)
             
             try:
                 raw_data = raw_input(msg_rep["content"]["prompt"])
             except EOFError:
                 # turn EOFError into EOF character
                 raw_data = '\x04'
             except KeyboardInterrupt:
                 sys.stdout.write('\n')
                 return
             finally:
                 # restore SIGINT handler
                 signal.signal(signal.SIGINT, real_handler)
             
             # only send stdin reply if there *was not* another request
             # or execution finished while we were reading.
             if not (self.client.stdin_channel.msg_ready() or self.client.shell_channel.msg_ready()):
                 self.client.stdin_channel.input(raw_data)
 
     def mainloop(self, display_banner=False):
         while True:
             try:
                 self.interact(display_banner=display_banner)
                 #self.interact_with_readline()                
                 # XXX for testing of a readline-decoupled repl loop, call
                 # interact_with_readline above
                 break
             except KeyboardInterrupt:
                 # this should not be necessary, but KeyboardInterrupt
                 # handling seems rather unpredictable...
                 self.write("\nKeyboardInterrupt in interact()\n")
     
     def wait_for_kernel(self, timeout=None):
         """method to wait for a kernel to be ready"""
         tic = time.time()
         self.client.hb_channel.unpause()
         while True:
             self.run_cell('1', False)
             if self.client.hb_channel.is_beating():
                 # heart failure was not the reason this returned
                 break
             else:
                 # heart failed
                 if timeout is not None and (time.time() - tic) > timeout:
                     return False
         return True
     
     def interact(self, display_banner=None):
         """Closely emulate the interactive Python console."""
 
         # batch run -> do not interact
         if self.exit_now:
             return
 
         if display_banner is None:
             display_banner = self.display_banner
         
         if isinstance(display_banner, basestring):
             self.show_banner(display_banner)
         elif display_banner:
             self.show_banner()
 
         more = False
         
         # run a non-empty no-op, so that we don't get a prompt until
         # we know the kernel is ready. This keeps the connection
         # message above the first prompt.
         if not self.wait_for_kernel(3):
             error("Kernel did not respond\n")
             return
         
         if self.has_readline:
             self.readline_startup_hook(self.pre_readline)
             hlen_b4_cell = self.readline.get_current_history_length()
         else:
             hlen_b4_cell = 0
         # exit_now is set by a call to %Exit or %Quit, through the
         # ask_exit callback.
 
         while not self.exit_now:
             if not self.client.is_alive():
                 # kernel died, prompt for action or exit
 
                 action = "restart" if self.manager else "wait for restart"
                 ans = self.ask_yes_no("kernel died, %s ([y]/n)?" % action, default='y')
                 if ans:
                     if self.manager:
                         self.manager.restart_kernel(True)
                     self.wait_for_kernel(3)
                 else:
                     self.exit_now = True
                 continue
             try:
                 # protect prompt block from KeyboardInterrupt
                 # when sitting on ctrl-C
                 self.hooks.pre_prompt_hook()
                 if more:
                     try:
                         prompt = self.prompt_manager.render('in2')
                     except Exception:
                         self.showtraceback()
                     if self.autoindent:
                         self.rl_do_indent = True
                     
                 else:
                     try:
                         prompt = self.separate_in + self.prompt_manager.render('in')
                     except Exception:
                         self.showtraceback()
                 
                 line = self.raw_input(prompt)
                 if self.exit_now:
                     # quick exit on sys.std[in|out] close
                     break
                 if self.autoindent:
                     self.rl_do_indent = False
                     
             except KeyboardInterrupt:
                 #double-guard against keyboardinterrupts during kbdint handling
                 try:
                     self.write('\nKeyboardInterrupt\n')
                     source_raw = self.input_splitter.source_raw_reset()[1]
                     hlen_b4_cell = self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
                     more = False
                 except KeyboardInterrupt:
                     pass
             except EOFError:
                 if self.autoindent:
                     self.rl_do_indent = False
                     if self.has_readline:
                         self.readline_startup_hook(None)
                 self.write('\n')
                 self.exit()
             except bdb.BdbQuit:
                 warn('The Python debugger has exited with a BdbQuit exception.\n'
                      'Because of how pdb handles the stack, it is impossible\n'
                      'for IPython to properly format this particular exception.\n'
                      'IPython will resume normal operation.')
             except:
                 # exceptions here are VERY RARE, but they can be triggered
                 # asynchronously by signal handlers, for example.
                 self.showtraceback()
             else:
                 self.input_splitter.push(line)
                 more = self.input_splitter.push_accepts_more()
                 if (self.SyntaxTB.last_syntax_error and
                     self.autoedit_syntax):
                     self.edit_syntax_error()
                 if not more:
                     source_raw = self.input_splitter.source_raw_reset()[1]
                     hlen_b4_cell = self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
                     self.run_cell(source_raw)
                 
 
         # Turn off the exit flag, so the mainloop can be restarted if desired
         self.exit_now = False

IPython/terminal/console/tests/test_image_handler.py

@@ -1,95 +1,94 b''
 #-----------------------------------------------------------------------------
 # Copyright (C) 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.
 #-----------------------------------------------------------------------------
 
 import os
 import sys
 import unittest
 import base64
 
 from IPython.kernel import KernelClient
-from IPython.frontend.terminal.console.interactiveshell \
-    import ZMQTerminalInteractiveShell
+from IPython.terminal.console.interactiveshell import ZMQTerminalInteractiveShell
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.testing.tools import monkeypatch
 from IPython.testing.decorators import skip_without
 from IPython.utils.ipstruct import Struct
 
 
 SCRIPT_PATH = os.path.join(
     os.path.abspath(os.path.dirname(__file__)), 'writetofile.py')
 
 
 class ZMQTerminalInteractiveShellTestCase(unittest.TestCase):
 
     def setUp(self):
         client = KernelClient()
         self.shell = ZMQTerminalInteractiveShell(kernel_client=client)
         self.raw = b'dummy data'
         self.mime = 'image/png'
         self.data = {self.mime: base64.encodestring(self.raw).decode('ascii')}
 
     def test_no_call_by_default(self):
         def raise_if_called(*args, **kwds):
             assert False
 
         shell = self.shell
         shell.handle_image_PIL = raise_if_called
         shell.handle_image_stream = raise_if_called
         shell.handle_image_tempfile = raise_if_called
         shell.handle_image_callable = raise_if_called
 
         shell.handle_image(None, None)  # arguments are dummy
 
     @skip_without('PIL')
     def test_handle_image_PIL(self):
         import PIL.Image
 
         open_called_with = []
         show_called_with = []
 
         def fake_open(arg):
             open_called_with.append(arg)
             return Struct(show=lambda: show_called_with.append(None))
 
         with monkeypatch(PIL.Image, 'open', fake_open):
             self.shell.handle_image_PIL(self.data, self.mime)
 
         self.assertEqual(len(open_called_with), 1)
         self.assertEqual(len(show_called_with), 1)
         self.assertEqual(open_called_with[0].getvalue(), self.raw)
 
     def check_handler_with_file(self, inpath, handler):
         shell = self.shell
         configname = '{0}_image_handler'.format(handler)
         funcname = 'handle_image_{0}'.format(handler)
 
         assert hasattr(shell, configname)
         assert hasattr(shell, funcname)
 
         with TemporaryDirectory() as tmpdir:
             outpath = os.path.join(tmpdir, 'data')
             cmd = [sys.executable, SCRIPT_PATH, inpath, outpath]
             setattr(shell, configname, cmd)
             getattr(shell, funcname)(self.data, self.mime)
             # cmd is called and file is closed.  So it's safe to open now.
             with open(outpath, 'rb') as file:
                 transferred = file.read()
 
         self.assertEqual(transferred, self.raw)
 
     def test_handle_image_stream(self):
         self.check_handler_with_file('-', 'stream')
 
     def test_handle_image_tempfile(self):
         self.check_handler_with_file('{file}', 'tempfile')
 
     def test_handle_image_callable(self):
         called_with = []
         self.shell.callable_image_handler = called_with.append
         self.shell.handle_image_callable(self.data, self.mime)
         self.assertEqual(len(called_with), 1)
         assert called_with[0] is self.data

IPython/terminal/embed.py

@@ -1,296 +1,296 b''
 # encoding: utf-8
 """
 An embedded IPython shell.
 
 Authors:
 
 * Brian Granger
 * Fernando Perez
 
 Notes
 -----
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  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
 #-----------------------------------------------------------------------------
 
 from __future__ import with_statement
 
 import sys
 import warnings
 
 # We need to use nested to support python 2.6, once we move to >=2.7, we can
 # use the with keyword's new builtin support for nested managers
 try:
     from contextlib import nested
 except:
     from IPython.utils.nested_context import nested
 
 from IPython.core import ultratb, compilerop
 from IPython.core.magic import Magics, magics_class, line_magic
-from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
-from IPython.frontend.terminal.ipapp import load_default_config
+from IPython.terminal.interactiveshell import TerminalInteractiveShell
+from IPython.terminal.ipapp import load_default_config
 
 from IPython.utils.traitlets import Bool, CBool, Unicode
 from IPython.utils.io import ask_yes_no
 
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 # This is an additional magic that is exposed in embedded shells.
 @magics_class
 class EmbeddedMagics(Magics):
 
     @line_magic
     def kill_embedded(self, parameter_s=''):
         """%kill_embedded : deactivate for good the current embedded IPython.
 
         This function (after asking for confirmation) sets an internal flag so
         that an embedded IPython will never activate again.  This is useful to
         permanently disable a shell that is being called inside a loop: once
         you've figured out what you needed from it, you may then kill it and
         the program will then continue to run without the interactive shell
         interfering again.
         """
 
         kill = ask_yes_no("Are you sure you want to kill this embedded instance "
                          "(y/n)? [y/N] ",'n')
         if kill:
             self.shell.embedded_active = False
             print ("This embedded IPython will not reactivate anymore "
                    "once you exit.")
 
 
 class InteractiveShellEmbed(TerminalInteractiveShell):
 
     dummy_mode = Bool(False)
     exit_msg = Unicode('')
     embedded = CBool(True)
     embedded_active = CBool(True)
     # Like the base class display_banner is not configurable, but here it
     # is True by default.
     display_banner = CBool(True)
 
     def __init__(self, config=None, ipython_dir=None, user_ns=None,
                  user_module=None, custom_exceptions=((),None),
                  usage=None, banner1=None, banner2=None,
                  display_banner=None, exit_msg=u'', user_global_ns=None):
     
         if user_global_ns is not None:
             warnings.warn("user_global_ns has been replaced by user_module. The\
                            parameter will be ignored.", DeprecationWarning)
 
         super(InteractiveShellEmbed,self).__init__(
             config=config, ipython_dir=ipython_dir, user_ns=user_ns,
             user_module=user_module, custom_exceptions=custom_exceptions,
             usage=usage, banner1=banner1, banner2=banner2,
             display_banner=display_banner
         )
 
         self.exit_msg = exit_msg
 
         # don't use the ipython crash handler so that user exceptions aren't
         # trapped
         sys.excepthook = ultratb.FormattedTB(color_scheme=self.colors,
                                              mode=self.xmode,
                                              call_pdb=self.pdb)
 
     def init_sys_modules(self):
         pass
 
     def init_magics(self):
         super(InteractiveShellEmbed, self).init_magics()
         self.register_magics(EmbeddedMagics)
 
     def __call__(self, header='', local_ns=None, module=None, dummy=None,
                  stack_depth=1, global_ns=None, compile_flags=None):
         """Activate the interactive interpreter.
 
         __call__(self,header='',local_ns=None,module=None,dummy=None) -> Start
         the interpreter shell with the given local and global namespaces, and
         optionally print a header string at startup.
 
         The shell can be globally activated/deactivated using the
         dummy_mode attribute. This allows you to turn off a shell used
         for debugging globally.
 
         However, *each* time you call the shell you can override the current
         state of dummy_mode with the optional keyword parameter 'dummy'. For
         example, if you set dummy mode on with IPShell.dummy_mode = True, you
         can still have a specific call work by making it as IPShell(dummy=False).
         """
 
         # If the user has turned it off, go away
         if not self.embedded_active:
             return
 
         # Normal exits from interactive mode set this flag, so the shell can't
         # re-enter (it checks this variable at the start of interactive mode).
         self.exit_now = False
 
         # Allow the dummy parameter to override the global __dummy_mode
         if dummy or (dummy != 0 and self.dummy_mode):
             return
 
         if self.has_readline:
             self.set_readline_completer()
 
         # self.banner is auto computed
         if header:
             self.old_banner2 = self.banner2
             self.banner2 = self.banner2 + '\n' + header + '\n'
         else:
             self.old_banner2 = ''
 
         # Call the embedding code with a stack depth of 1 so it can skip over
         # our call and get the original caller's namespaces.
         self.mainloop(local_ns, module, stack_depth=stack_depth,
                       global_ns=global_ns, compile_flags=compile_flags)
 
         self.banner2 = self.old_banner2
 
         if self.exit_msg is not None:
             print self.exit_msg
 
     def mainloop(self, local_ns=None, module=None, stack_depth=0,
                  display_banner=None, global_ns=None, compile_flags=None):
         """Embeds IPython into a running python program.
 
         Input:
 
           - header: An optional header message can be specified.
 
           - local_ns, module: working local namespace (a dict) and module (a
           module or similar object). If given as None, they are automatically
           taken from the scope where the shell was called, so that
           program variables become visible.
 
           - stack_depth: specifies how many levels in the stack to go to
           looking for namespaces (when local_ns or module is None).  This
           allows an intermediate caller to make sure that this function gets
           the namespace from the intended level in the stack.  By default (0)
           it will get its locals and globals from the immediate caller.
 
           - compile_flags: A bit field identifying the __future__ features
           that are enabled, as passed to the builtin `compile` function. If
           given as None, they are automatically taken from the scope where the
           shell was called.
 
         Warning: it's possible to use this in a program which is being run by
         IPython itself (via %run), but some funny things will happen (a few
         globals get overwritten). In the future this will be cleaned up, as
         there is no fundamental reason why it can't work perfectly."""
         
         if (global_ns is not None) and (module is None):
             class DummyMod(object):
                 """A dummy module object for embedded IPython."""
                 pass
             warnings.warn("global_ns is deprecated, use module instead.", DeprecationWarning)
             module = DummyMod()
             module.__dict__ = global_ns
 
         # Get locals and globals from caller
         if ((local_ns is None or module is None or compile_flags is None)
             and self.default_user_namespaces):
             call_frame = sys._getframe(stack_depth).f_back
 
             if local_ns is None:
                 local_ns = call_frame.f_locals
             if module is None:
                 global_ns = call_frame.f_globals
                 module = sys.modules[global_ns['__name__']]
             if compile_flags is None:
                 compile_flags = (call_frame.f_code.co_flags &
                                  compilerop.PyCF_MASK)
         
         # Save original namespace and module so we can restore them after 
         # embedding; otherwise the shell doesn't shut down correctly.
         orig_user_module = self.user_module
         orig_user_ns = self.user_ns
         orig_compile_flags = self.compile.flags
         
         # Update namespaces and fire up interpreter
         
         # The global one is easy, we can just throw it in
         if module is not None:
             self.user_module = module
 
         # But the user/local one is tricky: ipython needs it to store internal
         # data, but we also need the locals. We'll throw our hidden variables
         # like _ih and get_ipython() into the local namespace, but delete them
         # later.
         if local_ns is not None:
             self.user_ns = local_ns
             self.init_user_ns()
 
         # Compiler flags
         if compile_flags is not None:
             self.compile.flags = compile_flags
 
         # Patch for global embedding to make sure that things don't overwrite
         # user globals accidentally. Thanks to Richard <[e-mail]>
         # FIXME. Test this a bit more carefully (the if.. is new)
         # N.B. This can't now ever be called. Not sure what it was for.
         # And now, since it wasn't called in the previous version, I'm
         # commenting out these lines so they can't be called with my new changes
         # --TK, 2011-12-10
         #if local_ns is None and module is None:
         #    self.user_global_ns.update(__main__.__dict__)
 
         # make sure the tab-completer has the correct frame information, so it
         # actually completes using the frame's locals/globals
         self.set_completer_frame()
 
         with nested(self.builtin_trap, self.display_trap):
             self.interact(display_banner=display_banner)
         
         # now, purge out the local namespace of IPython's hidden variables.
         if local_ns is not None:
             for name in self.user_ns_hidden:
                 local_ns.pop(name, None)
         
         # Restore original namespace so shell can shut down when we exit.
         self.user_module = orig_user_module
         self.user_ns = orig_user_ns
         self.compile.flags = orig_compile_flags
 
 
 def embed(**kwargs):
     """Call this to embed IPython at the current point in your program.
 
     The first invocation of this will create an :class:`InteractiveShellEmbed`
     instance and then call it.  Consecutive calls just call the already
     created instance.
 
     Here is a simple example::
 
         from IPython import embed
         a = 10
         b = 20
         embed('First time')
         c = 30
         d = 40
         embed
 
     Full customization can be done by passing a :class:`Config` in as the
     config argument.
     """
     config = kwargs.get('config')
     header = kwargs.pop('header', u'')
     compile_flags = kwargs.pop('compile_flags', None)
     if config is None:
         config = load_default_config()
         config.InteractiveShellEmbed = config.TerminalInteractiveShell
         kwargs['config'] = config
     shell = InteractiveShellEmbed.instance(**kwargs)
     shell(header=header, stack_depth=2, compile_flags=compile_flags)

IPython/terminal/ipapp.py

@@ -1,395 +1,395 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 The :class:`~IPython.core.application.Application` object for the command
 line :command:`ipython` program.
 
 Authors
 -------
 
 * Brian Granger
 * Fernando Perez
 * Min Ragan-Kelley
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  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
 #-----------------------------------------------------------------------------
 
 from __future__ import absolute_import
 
 import logging
 import os
 import sys
 
 from IPython.config.loader import (
     Config, PyFileConfigLoader, ConfigFileNotFound
 )
 from IPython.config.application import boolean_flag, catch_config_error
 from IPython.core import release
 from IPython.core import usage
 from IPython.core.completer import IPCompleter
 from IPython.core.crashhandler import CrashHandler
 from IPython.core.formatters import PlainTextFormatter
 from IPython.core.history import HistoryManager
 from IPython.core.prompts import PromptManager
 from IPython.core.application import (
     ProfileDir, BaseIPythonApplication, base_flags, base_aliases
 )
 from IPython.core.magics import ScriptMagics
 from IPython.core.shellapp import (
     InteractiveShellApp, shell_flags, shell_aliases
 )
-from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
+from IPython.terminal.interactiveshell import TerminalInteractiveShell
 from IPython.utils import warn
 from IPython.utils.path import get_ipython_dir, check_for_old_config
 from IPython.utils.traitlets import (
     Bool, List, Dict, CaselessStrEnum
 )
 
 #-----------------------------------------------------------------------------
 # Globals, utilities and helpers
 #-----------------------------------------------------------------------------
 
 #: The default config file name for this application.
 default_config_file_name = u'ipython_config.py'
 
 _examples = """
 ipython --pylab            # start in pylab mode
 ipython --pylab=qt         # start in pylab mode with the qt4 backend
 ipython --log-level=DEBUG  # set logging to DEBUG
 ipython --profile=foo      # start with profile foo
 
 ipython qtconsole          # start the qtconsole GUI application
 ipython help qtconsole     # show the help for the qtconsole subcmd
 
 ipython console            # start the terminal-based console application
 ipython help console       # show the help for the console subcmd
 
 ipython notebook           # start the IPython notebook
 ipython help notebook      # show the help for the notebook subcmd
 
 ipython profile create foo # create profile foo w/ default config files
 ipython help profile       # show the help for the profile subcmd
 
 ipython locate             # print the path to the IPython directory
 ipython locate profile foo # print the path to the directory for profile `foo`
 """
 
 #-----------------------------------------------------------------------------
 # Crash handler for this application
 #-----------------------------------------------------------------------------
 
 class IPAppCrashHandler(CrashHandler):
     """sys.excepthook for IPython itself, leaves a detailed report on disk."""
 
     def __init__(self, app):
         contact_name = release.author
         contact_email = release.author_email
         bug_tracker = 'https://github.com/ipython/ipython/issues'
         super(IPAppCrashHandler,self).__init__(
             app, contact_name, contact_email, bug_tracker
         )
 
     def make_report(self,traceback):
         """Return a string containing a crash report."""
 
         sec_sep = self.section_sep
         # Start with parent report
         report = [super(IPAppCrashHandler, self).make_report(traceback)]
         # Add interactive-specific info we may have
         rpt_add = report.append
         try:
             rpt_add(sec_sep+"History of session input:")
             for line in self.app.shell.user_ns['_ih']:
                 rpt_add(line)
             rpt_add('\n*** Last line of input (may not be in above history):\n')
             rpt_add(self.app.shell._last_input_line+'\n')
         except:
             pass
 
         return ''.join(report)
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 flags = dict(base_flags)
 flags.update(shell_flags)
 frontend_flags = {}
 addflag = lambda *args: frontend_flags.update(boolean_flag(*args))
 addflag('autoedit-syntax', 'TerminalInteractiveShell.autoedit_syntax',
         'Turn on auto editing of files with syntax errors.',
         'Turn off auto editing of files with syntax errors.'
 )
 addflag('banner', 'TerminalIPythonApp.display_banner',
         "Display a banner upon starting IPython.",
         "Don't display a banner upon starting IPython."
 )
 addflag('confirm-exit', 'TerminalInteractiveShell.confirm_exit',
     """Set to confirm when you try to exit IPython with an EOF (Control-D
     in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
     you can force a direct exit without any confirmation.""",
     "Don't prompt the user when exiting."
 )
 addflag('term-title', 'TerminalInteractiveShell.term_title',
     "Enable auto setting the terminal title.",
     "Disable auto setting the terminal title."
 )
 classic_config = Config()
 classic_config.InteractiveShell.cache_size = 0
 classic_config.PlainTextFormatter.pprint = False
 classic_config.PromptManager.in_template = '>>> '
 classic_config.PromptManager.in2_template = '... '
 classic_config.PromptManager.out_template = ''
 classic_config.InteractiveShell.separate_in = ''
 classic_config.InteractiveShell.separate_out = ''
 classic_config.InteractiveShell.separate_out2 = ''
 classic_config.InteractiveShell.colors = 'NoColor'
 classic_config.InteractiveShell.xmode = 'Plain'
 
 frontend_flags['classic']=(
     classic_config,
     "Gives IPython a similar feel to the classic Python prompt."
 )
 # # log doesn't make so much sense this way anymore
 # paa('--log','-l',
 #     action='store_true', dest='InteractiveShell.logstart',
 #     help="Start logging to the default log file (./ipython_log.py).")
 #
 # # quick is harder to implement
 frontend_flags['quick']=(
     {'TerminalIPythonApp' : {'quick' : True}},
     "Enable quick startup with no config files."
 )
 
 frontend_flags['i'] = (
     {'TerminalIPythonApp' : {'force_interact' : True}},
     """If running code from the command line, become interactive afterwards.
     Note: can also be given simply as '-i.'"""
 )
 flags.update(frontend_flags)
 
 aliases = dict(base_aliases)
 aliases.update(shell_aliases)
 
 #-----------------------------------------------------------------------------
 # Main classes and functions
 #-----------------------------------------------------------------------------
 
 
 class LocateIPythonApp(BaseIPythonApplication):
     description = """print the path to the IPython dir"""
     subcommands = Dict(dict(
         profile=('IPython.core.profileapp.ProfileLocate',
             "print the path to an IPython profile directory",
         ),
     ))
     def start(self):
         if self.subapp is not None:
             return self.subapp.start()
         else:
             print self.ipython_dir
 
 
 class TerminalIPythonApp(BaseIPythonApplication, InteractiveShellApp):
     name = u'ipython'
     description = usage.cl_usage
     default_config_file_name = default_config_file_name
     crash_handler_class = IPAppCrashHandler
     examples = _examples
 
     flags = Dict(flags)
     aliases = Dict(aliases)
     classes = List()
     def _classes_default(self):
         """This has to be in a method, for TerminalIPythonApp to be available."""
         return [
             InteractiveShellApp, # ShellApp comes before TerminalApp, because
             self.__class__,      # it will also affect subclasses (e.g. QtConsole)
             TerminalInteractiveShell,
             PromptManager,
             HistoryManager,
             ProfileDir,
             PlainTextFormatter,
             IPCompleter,
             ScriptMagics,
         ]
 
     subcommands = Dict(dict(
-        qtconsole=('IPython.frontend.qt.console.qtconsoleapp.IPythonQtConsoleApp',
+        qtconsole=('IPython.qt.console.qtconsoleapp.IPythonQtConsoleApp',
             """Launch the IPython Qt Console."""
         ),
-        notebook=('IPython.frontend.html.notebook.notebookapp.NotebookApp',
+        notebook=('IPython.html.notebookapp.NotebookApp',
             """Launch the IPython HTML Notebook Server."""
         ),
         profile = ("IPython.core.profileapp.ProfileApp",
             "Create and manage IPython profiles."
         ),
         kernel = ("IPython.kernel.zmq.kernelapp.IPKernelApp",
             "Start a kernel without an attached frontend."
         ),
-        console=('IPython.frontend.terminal.console.app.ZMQTerminalIPythonApp',
+        console=('IPython.terminal.console.app.ZMQTerminalIPythonApp',
             """Launch the IPython terminal-based Console."""
         ),
-        locate=('IPython.frontend.terminal.ipapp.LocateIPythonApp',
+        locate=('IPython.terminal.ipapp.LocateIPythonApp',
             LocateIPythonApp.description
         ),
         history=('IPython.core.historyapp.HistoryApp',
             "Manage the IPython history database."
         ),
     ))
 
     # *do* autocreate requested profile, but don't create the config file.
     auto_create=Bool(True)
     # configurables
     ignore_old_config=Bool(False, config=True,
         help="Suppress warning messages about legacy config files"
     )
     quick = Bool(False, config=True,
         help="""Start IPython quickly by skipping the loading of config files."""
     )
     def _quick_changed(self, name, old, new):
         if new:
             self.load_config_file = lambda *a, **kw: None
             self.ignore_old_config=True
 
     display_banner = Bool(True, config=True,
         help="Whether to display a banner upon starting IPython."
     )
 
     # if there is code of files to run from the cmd line, don't interact
     # unless the --i flag (App.force_interact) is true.
     force_interact = Bool(False, config=True,
         help="""If a command or file is given via the command-line,
         e.g. 'ipython foo.py"""
     )
     def _force_interact_changed(self, name, old, new):
         if new:
             self.interact = True
 
     def _file_to_run_changed(self, name, old, new):
         if new:
             self.something_to_run = True
         if new and not self.force_interact:
                 self.interact = False
     _code_to_run_changed = _file_to_run_changed
     _module_to_run_changed = _file_to_run_changed
 
     # internal, not-configurable
     interact=Bool(True)
     something_to_run=Bool(False)
 
     def parse_command_line(self, argv=None):
         """override to allow old '-pylab' flag with deprecation warning"""
 
         argv = sys.argv[1:] if argv is None else argv
 
         if '-pylab' in argv:
             # deprecated `-pylab` given,
             # warn and transform into current syntax
             argv = argv[:] # copy, don't clobber
             idx = argv.index('-pylab')
             warn.warn("`-pylab` flag has been deprecated.\n"
             "    Use `--pylab` instead, or `--pylab=foo` to specify a backend.")
             sub = '--pylab'
             if len(argv) > idx+1:
                 # check for gui arg, as in '-pylab qt'
                 gui = argv[idx+1]
                 if gui in ('wx', 'qt', 'qt4', 'gtk', 'auto'):
                     sub = '--pylab='+gui
                     argv.pop(idx+1)
             argv[idx] = sub
 
         return super(TerminalIPythonApp, self).parse_command_line(argv)
     
     @catch_config_error
     def initialize(self, argv=None):
         """Do actions after construct, but before starting the app."""
         super(TerminalIPythonApp, self).initialize(argv)
         if self.subapp is not None:
             # don't bother initializing further, starting subapp
             return
         if not self.ignore_old_config:
             check_for_old_config(self.ipython_dir)
         # print self.extra_args
         if self.extra_args and not self.something_to_run:
             self.file_to_run = self.extra_args[0]
         self.init_path()
         # create the shell
         self.init_shell()
         # and draw the banner
         self.init_banner()
         # Now a variety of things that happen after the banner is printed.
         self.init_gui_pylab()
         self.init_extensions()
         self.init_code()
 
     def init_shell(self):
         """initialize the InteractiveShell instance"""
         # Create an InteractiveShell instance.
         # shell.display_banner should always be False for the terminal
         # based app, because we call shell.show_banner() by hand below
         # so the banner shows *before* all extension loading stuff.
         self.shell = TerminalInteractiveShell.instance(config=self.config,
                         display_banner=False, profile_dir=self.profile_dir,
                         ipython_dir=self.ipython_dir)
         self.shell.configurables.append(self)
 
     def init_banner(self):
         """optionally display the banner"""
         if self.display_banner and self.interact:
             self.shell.show_banner()
         # Make sure there is a space below the banner.
         if self.log_level <= logging.INFO: print
 
     def _pylab_changed(self, name, old, new):
         """Replace --pylab='inline' with --pylab='auto'"""
         if new == 'inline':
             warn.warn("'inline' not available as pylab backend, "
                       "using 'auto' instead.")
             self.pylab = 'auto'
 
     def start(self):
         if self.subapp is not None:
             return self.subapp.start()
         # perform any prexec steps:
         if self.interact:
             self.log.debug("Starting IPython's mainloop...")
             self.shell.mainloop()
         else:
             self.log.debug("IPython not interactive...")
 
 
 def load_default_config(ipython_dir=None):
     """Load the default config file from the default ipython_dir.
 
     This is useful for embedded shells.
     """
     if ipython_dir is None:
         ipython_dir = get_ipython_dir()
     profile_dir = os.path.join(ipython_dir, 'profile_default')
     cl = PyFileConfigLoader(default_config_file_name, profile_dir)
     try:
         config = cl.load_config()
     except ConfigFileNotFound:
         # no config found
         config = Config()
     return config
 
 
 def launch_new_instance():
     """Create and run a full blown IPython instance"""
     app = TerminalIPythonApp.instance()
     app.initialize()
     app.start()
 
 
 if __name__ == '__main__':
     launch_new_instance()

IPython/testing/decorators.py

@@ -1,358 +1,360 b''
 # -*- coding: utf-8 -*-
 """Decorators for labeling test objects.
 
 Decorators that merely return a modified version of the original function
 object are straightforward.  Decorators that return a new function object need
 to use nose.tools.make_decorator(original_function)(decorator) in returning the
 decorator, in order to preserve metadata such as function name, setup and
 teardown functions and so on - see nose.tools for more information.
 
 This module provides a set of useful decorators meant to be ready to use in
 your own tests.  See the bottom of the file for the ready-made ones, and if you
 find yourself writing a new one that may be of generic use, add it here.
 
 Included decorators:
 
 
 Lightweight testing that remains unittest-compatible.
 
 - @parametric, for parametric test support that is vastly easier to use than
   nose's for debugging. With ours, if a test fails, the stack under inspection
   is that of the test and not that of the test framework.
 
 - An @as_unittest decorator can be used to tag any normal parameter-less
   function as a unittest TestCase.  Then, both nose and normal unittest will
   recognize it as such.  This will make it easier to migrate away from Nose if
   we ever need/want to while maintaining very lightweight tests.
 
 NOTE: This file contains IPython-specific decorators. Using the machinery in
 IPython.external.decorators, we import either numpy.testing.decorators if numpy is
 available, OR use equivalent code in IPython.external._decorators, which
 we've copied verbatim from numpy.
 
 Authors
 -------
 
 - Fernando Perez <[e-mail]>
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2009-2011  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
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import inspect
 import sys
 import tempfile
 import unittest
 
 # Third-party imports
 
 # This is Michele Simionato's decorator module, kept verbatim.
 from IPython.external.decorator import decorator
 
 # We already have python3-compliant code for parametric tests
 if sys.version[0]=='2':
     from _paramtestpy2 import parametric, ParametricTestCase
 else:
     from _paramtestpy3 import parametric, ParametricTestCase
 
 # Expose the unittest-driven decorators
 from ipunittest import ipdoctest, ipdocstring
 
 # Grab the numpy-specific decorators which we keep in a file that we
 # occasionally update from upstream: decorators.py is a copy of
 # numpy.testing.decorators, we expose all of it here.
 from IPython.external.decorators import *
 
 # For onlyif_cmd_exists decorator
 from IPython.utils.process import is_cmd_found
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 # Simple example of the basic idea
 def as_unittest(func):
     """Decorator to make a simple function into a normal test via unittest."""
     class Tester(unittest.TestCase):
         def test(self):
             func()
 
     Tester.__name__ = func.__name__
 
     return Tester
 
 # Utility functions
 
 def apply_wrapper(wrapper,func):
     """Apply a wrapper to a function for decoration.
 
     This mixes Michele Simionato's decorator tool with nose's make_decorator,
     to apply a wrapper in a decorator so that all nose attributes, as well as
     function signature and other properties, survive the decoration cleanly.
     This will ensure that wrapped functions can still be well introspected via
     IPython, for example.
     """
     import nose.tools
 
     return decorator(wrapper,nose.tools.make_decorator(func)(wrapper))
 
 
 def make_label_dec(label,ds=None):
     """Factory function to create a decorator that applies one or more labels.
 
     Parameters
     ----------
       label : string or sequence
       One or more labels that will be applied by the decorator to the functions
     it decorates.  Labels are attributes of the decorated function with their
     value set to True.
 
       ds : string
       An optional docstring for the resulting decorator.  If not given, a
       default docstring is auto-generated.
 
     Returns
     -------
       A decorator.
 
     Examples
     --------
 
     A simple labeling decorator:
-    >>> slow = make_label_dec('slow')
-    >>> print slow.__doc__
-    Labels a test as 'slow'.
 
+    >>> slow = make_label_dec('slow')
+    >>> slow.__doc__
+    "Labels a test as 'slow'."
+    
     And one that uses multiple labels and a custom docstring:
+    
     >>> rare = make_label_dec(['slow','hard'],
     ... "Mix labels 'slow' and 'hard' for rare tests.")
-    >>> print rare.__doc__
-    Mix labels 'slow' and 'hard' for rare tests.
+    >>> rare.__doc__
+    "Mix labels 'slow' and 'hard' for rare tests."
 
     Now, let's test using this one:
     >>> @rare
     ... def f(): pass
     ...
     >>>
     >>> f.slow
     True
     >>> f.hard
     True
     """
 
     if isinstance(label,basestring):
         labels = [label]
     else:
         labels = label
 
     # Validate that the given label(s) are OK for use in setattr() by doing a
     # dry run on a dummy function.
     tmp = lambda : None
     for label in labels:
         setattr(tmp,label,True)
 
     # This is the actual decorator we'll return
     def decor(f):
         for label in labels:
             setattr(f,label,True)
         return f
 
     # Apply the user's docstring, or autogenerate a basic one
     if ds is None:
         ds = "Labels a test as %r." % label
     decor.__doc__ = ds
 
     return decor
 
 
 # Inspired by numpy's skipif, but uses the full apply_wrapper utility to
 # preserve function metadata better and allows the skip condition to be a
 # callable.
 def skipif(skip_condition, msg=None):
     ''' Make function raise SkipTest exception if skip_condition is true
 
     Parameters
     ----------
     skip_condition : bool or callable.
         Flag to determine whether to skip test.  If the condition is a
         callable, it is used at runtime to dynamically make the decision.  This
         is useful for tests that may require costly imports, to delay the cost
         until the test suite is actually executed.
     msg : string
         Message to give on raising a SkipTest exception
 
    Returns
    -------
    decorator : function
        Decorator, which, when applied to a function, causes SkipTest
        to be raised when the skip_condition was True, and the function
        to be called normally otherwise.
 
     Notes
     -----
     You will see from the code that we had to further decorate the
     decorator with the nose.tools.make_decorator function in order to
     transmit function name, and various other metadata.
     '''
 
     def skip_decorator(f):
         # Local import to avoid a hard nose dependency and only incur the
         # import time overhead at actual test-time.
         import nose
 
         # Allow for both boolean or callable skip conditions.
         if callable(skip_condition):
             skip_val = skip_condition
         else:
             skip_val = lambda : skip_condition
 
         def get_msg(func,msg=None):
             """Skip message with information about function being skipped."""
             if msg is None: out = 'Test skipped due to test condition.'
             else: out = msg
             return "Skipping test: %s. %s" % (func.__name__,out)
 
         # We need to define *two* skippers because Python doesn't allow both
         # return with value and yield inside the same function.
         def skipper_func(*args, **kwargs):
             """Skipper for normal test functions."""
             if skip_val():
                 raise nose.SkipTest(get_msg(f,msg))
             else:
                 return f(*args, **kwargs)
 
         def skipper_gen(*args, **kwargs):
             """Skipper for test generators."""
             if skip_val():
                 raise nose.SkipTest(get_msg(f,msg))
             else:
                 for x in f(*args, **kwargs):
                     yield x
 
         # Choose the right skipper to use when building the actual generator.
         if nose.util.isgenerator(f):
             skipper = skipper_gen
         else:
             skipper = skipper_func
 
         return nose.tools.make_decorator(f)(skipper)
 
     return skip_decorator
 
 # A version with the condition set to true, common case just to attach a message
 # to a skip decorator
 def skip(msg=None):
     """Decorator factory - mark a test function for skipping from test suite.
 
     Parameters
     ----------
       msg : string
         Optional message to be added.
 
     Returns
     -------
        decorator : function
          Decorator, which, when applied to a function, causes SkipTest
          to be raised, with the optional message added.
       """
 
     return skipif(True,msg)
 
 
 def onlyif(condition, msg):
     """The reverse from skipif, see skipif for details."""
 
     if callable(condition):
         skip_condition = lambda : not condition()
     else:
         skip_condition = lambda : not condition
 
     return skipif(skip_condition, msg)
 
 #-----------------------------------------------------------------------------
 # Utility functions for decorators
 def module_not_available(module):
     """Can module be imported?  Returns true if module does NOT import.
 
     This is used to make a decorator to skip tests that require module to be
     available, but delay the 'import numpy' to test execution time.
     """
     try:
         mod = __import__(module)
         mod_not_avail = False
     except ImportError:
         mod_not_avail = True
 
     return mod_not_avail
 
 #-----------------------------------------------------------------------------
 # Decorators for public use
 
 # Decorators to skip certain tests on specific platforms.
 skip_win32 = skipif(sys.platform == 'win32',
                     "This test does not run under Windows")
 skip_linux = skipif(sys.platform.startswith('linux'),
                     "This test does not run under Linux")
 skip_osx = skipif(sys.platform == 'darwin',"This test does not run under OS X")
 
 
 # Decorators to skip tests if not on specific platforms.
 skip_if_not_win32 = skipif(sys.platform != 'win32',
                            "This test only runs under Windows")
 skip_if_not_linux = skipif(not sys.platform.startswith('linux'),
                            "This test only runs under Linux")
 skip_if_not_osx = skipif(sys.platform != 'darwin',
                          "This test only runs under OSX")
 
 # Other skip decorators
 
 # generic skip without module
 skip_without = lambda mod: skipif(module_not_available(mod), "This test requires %s" % mod)
 
 skipif_not_numpy = skip_without('numpy')
 
 skipif_not_matplotlib = skip_without('matplotlib')
 
 skipif_not_sympy = skip_without('sympy')
 
 skip_known_failure = knownfailureif(True,'This test is known to fail')
 
 known_failure_py3 = knownfailureif(sys.version_info[0] >= 3, 
                                     'This test is known to fail on Python 3.')
 
 # A null 'decorator', useful to make more readable code that needs to pick
 # between different decorators based on OS or other conditions
 null_deco = lambda f: f
 
 # Some tests only run where we can use unicode paths. Note that we can't just
 # check os.path.supports_unicode_filenames, which is always False on Linux.
 try:
     f = tempfile.NamedTemporaryFile(prefix=u"tmp€")
 except UnicodeEncodeError:
     unicode_paths = False
 else:
     unicode_paths = True
     f.close()
 
 onlyif_unicode_paths = onlyif(unicode_paths, ("This test is only applicable "
                                     "where we can use unicode in filenames."))
 
 
 def onlyif_cmds_exist(*commands):
     """
     Decorator to skip test when at least one of `commands` is not found.
     """
     for cmd in commands:
         if not is_cmd_found(cmd):
             return skip("This test runs only if command '{0}' "
                         "is installed".format(cmd))
     return null_deco

IPython/testing/globalipapp.py

@@ -1,176 +1,176 b''
 """Global IPython app to support test running.
 
 We must start our own ipython object and heavily muck with it so that all the
 modifications IPython makes to system behavior don't send the doctest machinery
 into a fit.  This code should be considered a gross hack, but it gets the job
 done.
 """
 from __future__ import absolute_import
 from __future__ import print_function
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2009-2011  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
 #-----------------------------------------------------------------------------
 
 # stdlib
 import __builtin__ as builtin_mod
 import os
 import sys
 
 # our own
 from . import tools
 
 from IPython.core import page
 from IPython.utils import io
 from IPython.utils import py3compat
-from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
+from IPython.terminal.interactiveshell import TerminalInteractiveShell
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 class StreamProxy(io.IOStream):
     """Proxy for sys.stdout/err.  This will request the stream *at call time*
     allowing for nose's Capture plugin's redirection of sys.stdout/err.
 
     Parameters
     ----------
     name : str
         The name of the stream. This will be requested anew at every call
     """
 
     def __init__(self, name):
         self.name=name
 
     @property
     def stream(self):
         return getattr(sys, self.name)
 
     def flush(self):
         self.stream.flush()
 
 # Hack to modify the %run command so we can sync the user's namespace with the
 # test globals.  Once we move over to a clean magic system, this will be done
 # with much less ugliness.
 
 class py_file_finder(object):
     def __init__(self,test_filename):
         self.test_filename = test_filename
 
     def __call__(self,name,win32=False):
         from IPython.utils.path import get_py_filename
         try:
             return get_py_filename(name,win32=win32)
         except IOError:
             test_dir = os.path.dirname(self.test_filename)
             new_path = os.path.join(test_dir,name)
             return get_py_filename(new_path,win32=win32)
 
 
 def _run_ns_sync(self,arg_s,runner=None):
     """Modified version of %run that syncs testing namespaces.
 
     This is strictly needed for running doctests that call %run.
     """
     #print('in run_ns_sync', arg_s, file=sys.stderr)  # dbg
     finder = py_file_finder(arg_s)
     return get_ipython().magic_run_ori(arg_s, runner, finder)
 
 
 def get_ipython():
     # This will get replaced by the real thing once we start IPython below
     return start_ipython()
 
 
 # A couple of methods to override those in the running IPython to interact
 # better with doctest (doctest captures on raw stdout, so we need to direct
 # various types of output there otherwise it will miss them).
 
 def xsys(self, cmd):
     """Replace the default system call with a capturing one for doctest.
     """
     # We use getoutput, but we need to strip it because pexpect captures
     # the trailing newline differently from commands.getoutput
     print(self.getoutput(cmd, split=False, depth=1).rstrip(), end='', file=sys.stdout)
     sys.stdout.flush()
 
 
 def _showtraceback(self, etype, evalue, stb):
     """Print the traceback purely on stdout for doctest to capture it.
     """
     print(self.InteractiveTB.stb2text(stb), file=sys.stdout)
 
 
 def start_ipython():
     """Start a global IPython shell, which we need for IPython-specific syntax.
     """
     global get_ipython
 
     # This function should only ever run once!
     if hasattr(start_ipython, 'already_called'):
         return
     start_ipython.already_called = True
 
     # Store certain global objects that IPython modifies
     _displayhook = sys.displayhook
     _excepthook = sys.excepthook
     _main = sys.modules.get('__main__')
 
     # Create custom argv and namespaces for our IPython to be test-friendly
     config = tools.default_config()
 
     # Create and initialize our test-friendly IPython instance.
     shell = TerminalInteractiveShell.instance(config=config,
                                               )
 
     # A few more tweaks needed for playing nicely with doctests...
 
     # remove history file
     shell.tempfiles.append(config.HistoryManager.hist_file)
 
     # These traps are normally only active for interactive use, set them
     # permanently since we'll be mocking interactive sessions.
     shell.builtin_trap.activate()
 
     # Modify the IPython system call with one that uses getoutput, so that we
     # can capture subcommands and print them to Python's stdout, otherwise the
     # doctest machinery would miss them.
     shell.system = py3compat.MethodType(xsys, shell)
     
     shell._showtraceback = py3compat.MethodType(_showtraceback, shell)
 
     # IPython is ready, now clean up some global state...
 
     # Deactivate the various python system hooks added by ipython for
     # interactive convenience so we don't confuse the doctest system
     sys.modules['__main__'] = _main
     sys.displayhook = _displayhook
     sys.excepthook = _excepthook
 
     # So that ipython magics and aliases can be doctested (they work by making
     # a call into a global _ip object).  Also make the top-level get_ipython
     # now return this without recursively calling here again.
     _ip = shell
     get_ipython = _ip.get_ipython
     builtin_mod._ip = _ip
     builtin_mod.get_ipython = get_ipython
 
     # To avoid extra IPython messages during testing, suppress io.stdout/stderr
     io.stdout = StreamProxy('stdout')
     io.stderr = StreamProxy('stderr')
     
     # Override paging, so we don't require user interaction during the tests.
     def nopage(strng, start=0, screen_lines=0, pager_cmd=None):
         print(strng)
     
     page.orig_page = page.page
     page.page = nopage
 
     return _ip

IPython/testing/iptest.py

@@ -1,603 +1,610 b''
 # -*- coding: utf-8 -*-
 """IPython Test Suite Runner.
 
 This module provides a main entry point to a user script to test IPython
 itself from the command line. There are two ways of running this script:
 
 1. With the syntax `iptest all`.  This runs our entire test suite by
    calling this script (with different arguments) recursively.  This
    causes modules and package to be tested in different processes, using nose
    or trial where appropriate.
 2. With the regular nose syntax, like `iptest -vvs IPython`.  In this form
    the script simply calls nose, but with special command line flags and
    plugins loaded.
 
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2009-2011  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
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 # Stdlib
 import glob
 import os
 import os.path as path
 import signal
 import sys
 import subprocess
 import tempfile
 import time
 import warnings
 
 # Note: monkeypatch!
 # We need to monkeypatch a small problem in nose itself first, before importing
 # it for actual use.  This should get into nose upstream, but its release cycle
 # is slow and we need it for our parametric tests to work correctly.
 from IPython.testing import nosepatch
 
 # Monkeypatch extra assert methods into nose.tools if they're not already there.
 # This can be dropped once we no longer test on Python 2.6
 from IPython.testing import nose_assert_methods
 
 # Now, proceed to import nose itself
 import nose.plugins.builtin
 from nose.plugins.xunit import Xunit
 from nose import SkipTest
 from nose.core import TestProgram
 
 # Our own imports
 from IPython.utils import py3compat
 from IPython.utils.importstring import import_item
 from IPython.utils.path import get_ipython_module_path, get_ipython_package_dir
 from IPython.utils.process import find_cmd, pycmd2argv
 from IPython.utils.sysinfo import sys_info
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.utils.warn import warn
 
 from IPython.testing import globalipapp
 from IPython.testing.plugin.ipdoctest import IPythonDoctest
 from IPython.external.decorators import KnownFailure, knownfailureif
 
 pjoin = path.join
 
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 
 #-----------------------------------------------------------------------------
 # Warnings control
 #-----------------------------------------------------------------------------
 
 # Twisted generates annoying warnings with Python 2.6, as will do other code
 # that imports 'sets' as of today
 warnings.filterwarnings('ignore', 'the sets module is deprecated',
                         DeprecationWarning )
 
 # This one also comes from Twisted
 warnings.filterwarnings('ignore', 'the sha module is deprecated',
                         DeprecationWarning)
 
 # Wx on Fedora11 spits these out
 warnings.filterwarnings('ignore', 'wxPython/wxWidgets release number mismatch',
                         UserWarning)
 
 # ------------------------------------------------------------------------------
 # Monkeypatch Xunit to count known failures as skipped.
 # ------------------------------------------------------------------------------
 def monkeypatch_xunit():
     try:
         knownfailureif(True)(lambda: None)()
     except Exception as e:
         KnownFailureTest = type(e)
 
     def addError(self, test, err, capt=None):
         if issubclass(err[0], KnownFailureTest):
             err = (SkipTest,) + err[1:]
         return self.orig_addError(test, err, capt)
 
     Xunit.orig_addError = Xunit.addError
     Xunit.addError = addError
 
 #-----------------------------------------------------------------------------
 # Logic for skipping doctests
 #-----------------------------------------------------------------------------
 def extract_version(mod):
     return mod.__version__
 
 def test_for(item, min_version=None, callback=extract_version):
     """Test to see if item is importable, and optionally check against a minimum
     version.
 
     If min_version is given, the default behavior is to check against the
     `__version__` attribute of the item, but specifying `callback` allows you to
     extract the value you are interested in. e.g::
 
         In [1]: import sys
 
         In [2]: from IPython.testing.iptest import test_for
 
         In [3]: test_for('sys', (2,6), callback=lambda sys: sys.version_info)
         Out[3]: True
 
     """
     try:
         check = import_item(item)
     except (ImportError, RuntimeError):
         # GTK reports Runtime error if it can't be initialized even if it's
         # importable.
         return False
     else:
         if min_version:
             if callback:
                 # extra processing step to get version to compare
                 check = callback(check)
 
             return check >= min_version
         else:
             return True
 
 # Global dict where we can store information on what we have and what we don't
 # have available at test run time
 have = {}
 
 have['curses'] = test_for('_curses')
 have['matplotlib'] = test_for('matplotlib')
 have['numpy'] = test_for('numpy')
 have['pexpect'] = test_for('IPython.external.pexpect')
 have['pymongo'] = test_for('pymongo')
 have['pygments'] = test_for('pygments')
 have['qt'] = test_for('IPython.external.qt')
 have['rpy2'] = test_for('rpy2')
 have['sqlite3'] = test_for('sqlite3')
 have['cython'] = test_for('Cython')
 have['oct2py'] = test_for('oct2py')
 have['tornado'] = test_for('tornado.version_info', (2,1,0), callback=None)
 have['jinja2'] = test_for('jinja2')
 have['wx'] = test_for('wx')
 have['wx.aui'] = test_for('wx.aui')
 have['azure'] = test_for('azure')
 
 min_zmq = (2,1,11)
 
 have['zmq'] = test_for('zmq.pyzmq_version_info', min_zmq, callback=lambda x: x())
 
 #-----------------------------------------------------------------------------
 # Functions and classes
 #-----------------------------------------------------------------------------
 
 def report():
     """Return a string with a summary report of test-related variables."""
 
     out = [ sys_info(), '\n']
 
     avail = []
     not_avail = []
 
     for k, is_avail in have.items():
         if is_avail:
             avail.append(k)
         else:
             not_avail.append(k)
 
     if avail:
         out.append('\nTools and libraries available at test time:\n')
         avail.sort()
         out.append('   ' + ' '.join(avail)+'\n')
 
     if not_avail:
         out.append('\nTools and libraries NOT available at test time:\n')
         not_avail.sort()
         out.append('   ' + ' '.join(not_avail)+'\n')
 
     return ''.join(out)
 
 
 def make_exclude():
     """Make patterns of modules and packages to exclude from testing.
 
     For the IPythonDoctest plugin, we need to exclude certain patterns that
     cause testing problems.  We should strive to minimize the number of
     skipped modules, since this means untested code.
 
     These modules and packages will NOT get scanned by nose at all for tests.
     """
     # Simple utility to make IPython paths more readably, we need a lot of
     # these below
     ipjoin = lambda *paths: pjoin('IPython', *paths)
 
     exclusions = [ipjoin('external'),
                   ipjoin('quarantine'),
                   ipjoin('deathrow'),
                   # This guy is probably attic material
                   ipjoin('testing', 'mkdoctests'),
                   # Testing inputhook will need a lot of thought, to figure out
                   # how to have tests that don't lock up with the gui event
                   # loops in the picture
                   ipjoin('lib', 'inputhook'),
                   # Config files aren't really importable stand-alone
                   ipjoin('config', 'profile'),
                   # The notebook 'static' directory contains JS, css and other
                   # files for web serving.  Occasionally projects may put a .py
                   # file in there (MathJax ships a conf.py), so we might as
                   # well play it safe and skip the whole thing.
-                  ipjoin('frontend', 'html', 'notebook', 'static'),
-                  ipjoin('frontend', 'html', 'notebook', 'fabfile'),
+                  ipjoin('html', 'static'),
+                  ipjoin('html', 'fabfile'),
                   ]
     if not have['sqlite3']:
         exclusions.append(ipjoin('core', 'tests', 'test_history'))
         exclusions.append(ipjoin('core', 'history'))
     if not have['wx']:
         exclusions.append(ipjoin('lib', 'inputhookwx'))
     
     if 'IPython.kernel.inprocess' not in sys.argv:
         exclusions.append(ipjoin('kernel', 'inprocess'))
     
     # FIXME: temporarily disable autoreload tests, as they can produce
     # spurious failures in subsequent tests (cythonmagic).
     exclusions.append(ipjoin('extensions', 'autoreload'))
     exclusions.append(ipjoin('extensions', 'tests', 'test_autoreload'))
 
     # We do this unconditionally, so that the test suite doesn't import
     # gtk, changing the default encoding and masking some unicode bugs.
     exclusions.append(ipjoin('lib', 'inputhookgtk'))
     exclusions.append(ipjoin('kernel', 'zmq', 'gui', 'gtkembed'))
 
     # These have to be skipped on win32 because the use echo, rm, cd, etc.
     # See ticket https://github.com/ipython/ipython/issues/87
     if sys.platform == 'win32':
         exclusions.append(ipjoin('testing', 'plugin', 'test_exampleip'))
         exclusions.append(ipjoin('testing', 'plugin', 'dtexample'))
 
     if not have['pexpect']:
         exclusions.extend([ipjoin('lib', 'irunner'),
                            ipjoin('lib', 'tests', 'test_irunner'),
-                           ipjoin('frontend', 'terminal', 'console'),
+                           ipjoin('terminal', 'console'),
                            ])
 
     if not have['zmq']:
         exclusions.append(ipjoin('kernel'))
-        exclusions.append(ipjoin('frontend', 'qt'))
-        exclusions.append(ipjoin('frontend', 'html'))
-        exclusions.append(ipjoin('frontend', 'consoleapp.py'))
-        exclusions.append(ipjoin('frontend', 'terminal', 'console'))
+        exclusions.append(ipjoin('qt'))
+        exclusions.append(ipjoin('html'))
+        exclusions.append(ipjoin('consoleapp.py'))
+        exclusions.append(ipjoin('terminal', 'console'))
         exclusions.append(ipjoin('parallel'))
     elif not have['qt'] or not have['pygments']:
-        exclusions.append(ipjoin('frontend', 'qt'))
+        exclusions.append(ipjoin('qt'))
 
     if not have['pymongo']:
         exclusions.append(ipjoin('parallel', 'controller', 'mongodb'))
         exclusions.append(ipjoin('parallel', 'tests', 'test_mongodb'))
 
     if not have['matplotlib']:
         exclusions.extend([ipjoin('core', 'pylabtools'),
                            ipjoin('core', 'tests', 'test_pylabtools'),
                            ipjoin('kernel', 'zmq', 'pylab'),
         ])
 
     if not have['cython']:
         exclusions.extend([ipjoin('extensions', 'cythonmagic')])
         exclusions.extend([ipjoin('extensions', 'tests', 'test_cythonmagic')])
 
     if not have['oct2py']:
         exclusions.extend([ipjoin('extensions', 'octavemagic')])
         exclusions.extend([ipjoin('extensions', 'tests', 'test_octavemagic')])
 
     if not have['tornado']:
-        exclusions.append(ipjoin('frontend', 'html'))
+        exclusions.append(ipjoin('html'))
 
     if not have['jinja2']:
-        exclusions.append(ipjoin('frontend', 'html', 'notebook', 'notebookapp'))
+        exclusions.append(ipjoin('html', 'notebookapp'))
 
     if not have['rpy2'] or not have['numpy']:
         exclusions.append(ipjoin('extensions', 'rmagic'))
         exclusions.append(ipjoin('extensions', 'tests', 'test_rmagic'))
 
     if not have['azure']:
-        exclusions.append(ipjoin('frontend', 'html', 'notebook', 'services', 'notebooks', 'azurenbmanager'))
+        exclusions.append(ipjoin('html', 'services', 'notebooks', 'azurenbmanager'))
 
     # This is needed for the reg-exp to match on win32 in the ipdoctest plugin.
     if sys.platform == 'win32':
         exclusions = [s.replace('\\','\\\\') for s in exclusions]
     
     # check for any exclusions that don't seem to exist:
     parent, _ = os.path.split(get_ipython_package_dir())
     for exclusion in exclusions:
         if exclusion.endswith(('deathrow', 'quarantine')):
             # ignore deathrow/quarantine, which exist in dev, but not install
             continue
         fullpath = pjoin(parent, exclusion)
         if not os.path.exists(fullpath) and not glob.glob(fullpath + '.*'):
             warn("Excluding nonexistent file: %r" % exclusion)
 
     return exclusions
 
 
 class IPTester(object):
     """Call that calls iptest or trial in a subprocess.
     """
     #: string, name of test runner that will be called
     runner = None
     #: list, parameters for test runner
     params = None
     #: list, arguments of system call to be made to call test runner
     call_args = None
     #: list, subprocesses we start (for cleanup)
     processes = None
     #: str, coverage xml output file
     coverage_xml = None
 
     def __init__(self, runner='iptest', params=None):
         """Create new test runner."""
         p = os.path
         if runner == 'iptest':
             iptest_app = get_ipython_module_path('IPython.testing.iptest')
             self.runner = pycmd2argv(iptest_app) + sys.argv[1:]
         else:
             raise Exception('Not a valid test runner: %s' % repr(runner))
         if params is None:
             params = []
         if isinstance(params, str):
             params = [params]
         self.params = params
 
         # Assemble call
         self.call_args = self.runner+self.params
         
         # Find the section we're testing (IPython.foo)
         for sect in self.params:
             if sect.startswith('IPython'): break
         else:
             raise ValueError("Section not found", self.params)
         
         if '--with-xunit' in self.call_args:
             
             self.call_args.append('--xunit-file')
             # FIXME: when Windows uses subprocess.call, these extra quotes are unnecessary:
             xunit_file = path.abspath(sect+'.xunit.xml')
             if sys.platform == 'win32':
                 xunit_file = '"%s"' % xunit_file
             self.call_args.append(xunit_file)
         
         if '--with-xml-coverage' in self.call_args:
             self.coverage_xml = path.abspath(sect+".coverage.xml")
             self.call_args.remove('--with-xml-coverage')
             self.call_args = ["coverage", "run", "--source="+sect] + self.call_args[1:]
 
         # Store anything we start to clean up on deletion
         self.processes = []
 
     def _run_cmd(self):
         with TemporaryDirectory() as IPYTHONDIR:
             env = os.environ.copy()
             env['IPYTHONDIR'] = IPYTHONDIR
             # print >> sys.stderr, '*** CMD:', ' '.join(self.call_args) # dbg
             subp = subprocess.Popen(self.call_args, env=env)
             self.processes.append(subp)
             # If this fails, the process will be left in self.processes and
             # cleaned up later, but if the wait call succeeds, then we can
             # clear the stored process.
             retcode = subp.wait()
             self.processes.pop()
             return retcode
 
     def run(self):
         """Run the stored commands"""
         try:
             retcode = self._run_cmd()
         except KeyboardInterrupt:
             return -signal.SIGINT
         except:
             import traceback
             traceback.print_exc()
             return 1  # signal failure
         
         if self.coverage_xml:
             subprocess.call(["coverage", "xml", "-o", self.coverage_xml])
         return retcode
 
     def __del__(self):
         """Cleanup on exit by killing any leftover processes."""
         for subp in self.processes:
             if subp.poll() is not None:
                 continue # process is already dead
 
             try:
                 print('Cleaning up stale PID: %d' % subp.pid)
                 subp.kill()
             except: # (OSError, WindowsError) ?
                 # This is just a best effort, if we fail or the process was
                 # really gone, ignore it.
                 pass
             else:
                 for i in range(10):
                     if subp.poll() is None:
                         time.sleep(0.1)
                     else:
                         break
 
             if subp.poll() is None:
                 # The process did not die...
                 print('... failed. Manual cleanup may be required.')
 
+                
 def make_runners(inc_slow=False):
     """Define the top-level packages that need to be tested.
     """
 
     # Packages to be tested via nose, that only depend on the stdlib
-    nose_pkg_names = ['config', 'core', 'extensions', 'frontend', 'lib',
+    nose_pkg_names = ['config', 'core', 'extensions', 'lib', 'terminal',
                       'testing', 'utils', 'nbformat' ]
 
+    if have['qt']:
+        nose_pkg_names.append('qt')
+
+    if have['tornado']:
+        nose_pkg_names.append('html')
+        
     if have['zmq']:
         nose_pkg_names.append('kernel')
         nose_pkg_names.append('kernel.inprocess')
         if inc_slow:
             nose_pkg_names.append('parallel')
 
     # For debugging this code, only load quick stuff
     #nose_pkg_names = ['core', 'extensions']  # dbg
 
     # Make fully qualified package names prepending 'IPython.' to our name lists
     nose_packages = ['IPython.%s' % m for m in nose_pkg_names ]
 
     # Make runners
     runners = [ (v, IPTester('iptest', params=v)) for v in nose_packages ]
 
     return runners
 
 
 def run_iptest():
     """Run the IPython test suite using nose.
 
     This function is called when this script is **not** called with the form
     `iptest all`.  It simply calls nose with appropriate command line flags
     and accepts all of the standard nose arguments.
     """
     # Apply our monkeypatch to Xunit
     if '--with-xunit' in sys.argv and not hasattr(Xunit, 'orig_addError'):
         monkeypatch_xunit()
 
     warnings.filterwarnings('ignore',
         'This will be removed soon.  Use IPython.testing.util instead')
 
     argv = sys.argv + [ '--detailed-errors',  # extra info in tracebacks
 
                         '--with-ipdoctest',
                         '--ipdoctest-tests','--ipdoctest-extension=txt',
 
                         # We add --exe because of setuptools' imbecility (it
                         # blindly does chmod +x on ALL files).  Nose does the
                         # right thing and it tries to avoid executables,
                         # setuptools unfortunately forces our hand here.  This
                         # has been discussed on the distutils list and the
                         # setuptools devs refuse to fix this problem!
                         '--exe',
                         ]
     if '-a' not in argv and '-A' not in argv:
         argv = argv + ['-a', '!crash']
 
     if nose.__version__ >= '0.11':
         # I don't fully understand why we need this one, but depending on what
         # directory the test suite is run from, if we don't give it, 0 tests
         # get run.  Specifically, if the test suite is run from the source dir
         # with an argument (like 'iptest.py IPython.core', 0 tests are run,
         # even if the same call done in this directory works fine).  It appears
         # that if the requested package is in the current dir, nose bails early
         # by default.  Since it's otherwise harmless, leave it in by default
         # for nose >= 0.11, though unfortunately nose 0.10 doesn't support it.
         argv.append('--traverse-namespace')
 
     # use our plugin for doctesting.  It will remove the standard doctest plugin
     # if it finds it enabled
     plugins = [IPythonDoctest(make_exclude()), KnownFailure()]
     
     # We need a global ipython running in this process, but the special
     # in-process group spawns its own IPython kernels, so for *that* group we
     # must avoid also opening the global one (otherwise there's a conflict of
     # singletons).  Ultimately the solution to this problem is to refactor our
     # assumptions about what needs to be a singleton and what doesn't (app
     # objects should, individual shells shouldn't).  But for now, this
     # workaround allows the test suite for the inprocess module to complete.
     if not 'IPython.kernel.inprocess' in sys.argv:
         globalipapp.start_ipython()
 
     # Now nose can run
     TestProgram(argv=argv, addplugins=plugins)
 
 
 def run_iptestall(inc_slow=False):
     """Run the entire IPython test suite by calling nose and trial.
 
     This function constructs :class:`IPTester` instances for all IPython
     modules and package and then runs each of them.  This causes the modules
     and packages of IPython to be tested each in their own subprocess using
     nose.
     
     Parameters
     ----------
     
     inc_slow : bool, optional
       Include slow tests, like IPython.parallel. By default, these tests aren't
       run.
     """
 
     runners = make_runners(inc_slow=inc_slow)
 
     # Run the test runners in a temporary dir so we can nuke it when finished
     # to clean up any junk files left over by accident.  This also makes it
     # robust against being run in non-writeable directories by mistake, as the
     # temp dir will always be user-writeable.
     curdir = os.getcwdu()
     testdir = tempfile.gettempdir()
     os.chdir(testdir)
 
     # Run all test runners, tracking execution time
     failed = []
     t_start = time.time()
     try:
         for (name, runner) in runners:
             print('*'*70)
             print('IPython test group:',name)
             res = runner.run()
             if res:
                 failed.append( (name, runner) )
                 if res == -signal.SIGINT:
                     print("Interrupted")
                     break
     finally:
         os.chdir(curdir)
     t_end = time.time()
     t_tests = t_end - t_start
     nrunners = len(runners)
     nfail = len(failed)
     # summarize results
     print()
     print('*'*70)
     print('Test suite completed for system with the following information:')
     print(report())
     print('Ran %s test groups in %.3fs' % (nrunners, t_tests))
     print()
     print('Status:')
     if not failed:
         print('OK')
     else:
         # If anything went wrong, point out what command to rerun manually to
         # see the actual errors and individual summary
         print('ERROR - %s out of %s test groups failed.' % (nfail, nrunners))
         for name, failed_runner in failed:
             print('-'*40)
             print('Runner failed:',name)
             print('You may wish to rerun this one individually, with:')
             failed_call_args = [py3compat.cast_unicode(x) for x in failed_runner.call_args]
             print(u' '.join(failed_call_args))
             print()
         # Ensure that our exit code indicates failure
         sys.exit(1)
 
 
 def main():
     for arg in sys.argv[1:]:
         if arg.startswith('IPython'):
             # This is in-process
             run_iptest()
     else:
         if "--all" in sys.argv:
             sys.argv.remove("--all")
             inc_slow = True
         else:
             inc_slow = False
         # This starts subprocesses
         run_iptestall(inc_slow=inc_slow)
 
 
 if __name__ == '__main__':
     main()

IPython/utils/importstring.py

@@ -1,47 +1,50 b''
 # encoding: utf-8
 """
 A simple utility to import something by its string name.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Functions and classes
 #-----------------------------------------------------------------------------
 
 def import_item(name):
-    """Import and return bar given the string foo.bar."""
-    package = '.'.join(name.split('.')[0:-1])
-    obj = name.split('.')[-1]
-    
-    # Note: the original code for this was the following.  We've left it
-    # visible for now in case the new implementation shows any problems down
-    # the road, to make it easier on anyone looking for a problem.  This code
-    # should be removed once we're comfortable we didn't break anything.
+    """Import and return ``bar`` given the string ``foo.bar``.
+
+    Calling ``bar = import_item("foo.bar")`` is the functional equivalent of
+    executing the code ``from foo import bar``.
+
+    Parameters
+    ----------
+    name : string
+      The fully qualified name of the module/package being imported.
+
+    Returns
+    -------
+    mod : module object
+       The module that was imported.
+    """
     
-    ## execString = 'from %s import %s' % (package, obj)
-    ## try:
-    ##     exec execString
-    ## except SyntaxError:
-    ##     raise ImportError("Invalid class specification: %s" % name)
-    ## exec 'temp = %s' % obj
-    ## return temp
-
-    if package:
-        module = __import__(package,fromlist=[obj])
+    parts = name.rsplit('.', 1)
+    if len(parts) == 2:
+        # called with 'foo.bar....'
+        package, obj = parts
+        module = __import__(package, fromlist=[obj])
         try:
             pak = module.__dict__[obj]
         except KeyError:
             raise ImportError('No module named %s' % obj)
         return pak
     else:
-        return __import__(obj)
+        # called with un-dotted string
+        return __import__(parts[0])

IPython/utils/process.py

@@ -1,122 +1,122 b''
 # encoding: utf-8
 """
 Utilities for working with external processes.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  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
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 # Stdlib
 import os
 import sys
 import shlex
 
 # Our own
 if sys.platform == 'win32':
     from ._process_win32 import _find_cmd, system, getoutput, AvoidUNCPath, arg_split
 else:
     from ._process_posix import _find_cmd, system, getoutput, arg_split
 
 
 from ._process_common import getoutputerror
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 
 class FindCmdError(Exception):
     pass
 
 
 def find_cmd(cmd):
     """Find absolute path to executable cmd in a cross platform manner.
 
     This function tries to determine the full path to a command line program
     using `which` on Unix/Linux/OS X and `win32api` on Windows.  Most of the
     time it will use the version that is first on the users `PATH`.
 
     Warning, don't use this to find IPython command line programs as there
     is a risk you will find the wrong one.  Instead find those using the
     following code and looking for the application itself::
 
         from IPython.utils.path import get_ipython_module_path
         from IPython.utils.process import pycmd2argv
-        argv = pycmd2argv(get_ipython_module_path('IPython.frontend.terminal.ipapp'))
+        argv = pycmd2argv(get_ipython_module_path('IPython.terminal.ipapp'))
 
     Parameters
     ----------
     cmd : str
         The command line program to look for.
     """
     try:
         path = _find_cmd(cmd).rstrip()
     except OSError:
         raise FindCmdError('command could not be found: %s' % cmd)
     # which returns empty if not found
     if path == '':
         raise FindCmdError('command could not be found: %s' % cmd)
     return os.path.abspath(path)
 
 
 def is_cmd_found(cmd):
     """Check whether executable `cmd` exists or not and return a bool."""
     try:
         find_cmd(cmd)
         return True
     except FindCmdError:
         return False
 
 
 def pycmd2argv(cmd):
     r"""Take the path of a python command and return a list (argv-style).
 
     This only works on Python based command line programs and will find the
     location of the ``python`` executable using ``sys.executable`` to make
     sure the right version is used.
 
     For a given path ``cmd``, this returns [cmd] if cmd's extension is .exe,
     .com or .bat, and [, cmd] otherwise.
 
     Parameters
     ----------
     cmd : string
       The path of the command.
 
     Returns
     -------
     argv-style list.
     """
     ext = os.path.splitext(cmd)[1]
     if ext in ['.exe', '.com', '.bat']:
         return [cmd]
     else:
         return [sys.executable, cmd]
 
 
 def abbrev_cwd():
     """ Return abbreviated version of cwd, e.g. d:mydir """
     cwd = os.getcwdu().replace('\\','/')
     drivepart = ''
     tail = cwd
     if sys.platform == 'win32':
         if len(cwd) < 4:
             return cwd
         drivepart,tail = os.path.splitdrive(cwd)
 
 
     parts = tail.split('/')
     if len(parts) > 2:
         tail = '/'.join(parts[-2:])
 
     return (drivepart + (
         cwd == '/' and '/' or tail))

IPython/utils/submodule.py

@@ -1,92 +1,92 b''
 """utilities for checking submodule status"""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  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 os
 import subprocess
 import sys
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 pjoin = os.path.join
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 def ipython_parent():
     """return IPython's parent (i.e. root if run from git)"""
     from IPython.utils.path import get_ipython_package_dir
     return os.path.abspath(os.path.dirname(get_ipython_package_dir()))
 
 def ipython_submodules(root):
     """return IPython submodules relative to root"""
     return [
-        pjoin(root, 'IPython', 'frontend', 'html', 'notebook', 'static', 'components'),
+        pjoin(root, 'IPython', 'html', 'static', 'components'),
     ]
 
 def is_repo(d):
     """is d a git repo?"""
     return os.path.exists(pjoin(d, '.git'))
 
 def check_submodule_status(root=None):
     """check submodule status
 
     Has three return values:
 
     'missing' - submodules are absent
     'unclean' - submodules have unstaged changes
     'clean' - all submodules are up to date
     """
 
     if hasattr(sys, "frozen"):
         # frozen via py2exe or similar, don't bother
         return 'clean'
 
     if not root:
         root = ipython_parent()
     
     if not is_repo(root):
         # not in git, assume clean
         return 'clean'
 
     submodules = ipython_submodules(root)
 
     for submodule in submodules:
         if not os.path.exists(submodule):
             return 'missing'
 
     # check with git submodule status
     proc = subprocess.Popen('git submodule status',
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE,
                             shell=True,
                             cwd=root,
     )
     status, _ = proc.communicate()
     status = status.decode("ascii")
 
     for line in status.splitlines():
         if status.startswith('-'):
             return 'missing'
         elif status.startswith('+'):
             return 'unclean'
 
     return 'clean'
 
 def update_submodules(repo_dir):
     """update submodules in a repo"""
     subprocess.check_call("git submodule init", cwd=repo_dir, shell=True)
     subprocess.check_call("git submodule update --recursive", cwd=repo_dir, shell=True)
 

IPython/utils/tests/test_path.py

@@ -1,560 +1,560 b''
 # encoding: utf-8
 """Tests for IPython.utils.path.py"""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  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
 #-----------------------------------------------------------------------------
 
 from __future__ import with_statement
 
 import os
 import shutil
 import sys
 import tempfile
 from io import StringIO
 from contextlib import contextmanager
 
 from os.path import join, abspath, split
 
 import nose.tools as nt
 
 from nose import with_setup
 
 import IPython
 from IPython.testing import decorators as dec
 from IPython.testing.decorators import skip_if_not_win32, skip_win32
 from IPython.testing.tools import make_tempfile, AssertPrints
 from IPython.utils import path, io
 from IPython.utils import py3compat
 from IPython.utils.tempdir import TemporaryDirectory
 
 # Platform-dependent imports
 try:
     import _winreg as wreg
 except ImportError:
     #Fake _winreg module on none windows platforms
     import types
     wr_name = "winreg" if py3compat.PY3 else "_winreg"
     sys.modules[wr_name] = types.ModuleType(wr_name)
     import _winreg as wreg
     #Add entries that needs to be stubbed by the testing code
     (wreg.OpenKey, wreg.QueryValueEx,) = (None, None)
 
 try:
     reload
 except NameError:   # Python 3
     from imp import reload
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 env = os.environ
 TEST_FILE_PATH = split(abspath(__file__))[0]
 TMP_TEST_DIR = tempfile.mkdtemp()
 HOME_TEST_DIR = join(TMP_TEST_DIR, "home_test_dir")
 XDG_TEST_DIR = join(HOME_TEST_DIR, "xdg_test_dir")
 XDG_CACHE_DIR = join(HOME_TEST_DIR, "xdg_cache_dir")
 IP_TEST_DIR = join(HOME_TEST_DIR,'.ipython')
 #
 # Setup/teardown functions/decorators
 #
 
 def setup():
     """Setup testenvironment 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)
     os.makedirs(os.path.join(XDG_TEST_DIR, 'ipython'))
     os.makedirs(os.path.join(XDG_CACHE_DIR, 'ipython'))
 
 
 def teardown():
     """Teardown testenvironment 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)
 
 
 def setup_environment():
     """Setup testenvironment for some functions that are tested
     in this module. In particular this functions stores attributes
     and other things that we need to stub in some test functions.
     This needs to be done on a function level and not module level because
     each testfunction needs a pristine environment.
     """
     global oldstuff, platformstuff
     oldstuff = (env.copy(), os.name, sys.platform, path.get_home_dir, IPython.__file__, os.getcwd())
 
     if os.name == 'nt':
         platformstuff = (wreg.OpenKey, wreg.QueryValueEx,)
 
 
 def teardown_environment():
     """Restore things that were remebered by the setup_environment function
     """
     (oldenv, os.name, sys.platform, path.get_home_dir, IPython.__file__, old_wd) = oldstuff
     os.chdir(old_wd)
     reload(path)
 
     for key in env.keys():
         if key not in oldenv:
             del env[key]
     env.update(oldenv)
     if hasattr(sys, 'frozen'):
         del sys.frozen
     if os.name == 'nt':
         (wreg.OpenKey, wreg.QueryValueEx,) = platformstuff
 
 # Build decorator that uses the setup_environment/setup_environment
 with_environment = with_setup(setup_environment, teardown_environment)
 
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_1():
     """Testcase for py2exe logic, un-compressed lib
     """
     sys.frozen = True
 
     #fake filename for IPython.__init__
     IPython.__file__ = abspath(join(HOME_TEST_DIR, "Lib/IPython/__init__.py"))
 
     home_dir = path.get_home_dir()
     nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
 
 
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_2():
     """Testcase for py2exe logic, compressed lib
     """
     sys.frozen = True
     #fake filename for IPython.__init__
     IPython.__file__ = abspath(join(HOME_TEST_DIR, "Library.zip/IPython/__init__.py")).lower()
 
     home_dir = path.get_home_dir(True)
     nt.assert_equal(home_dir, abspath(HOME_TEST_DIR).lower())
 
 
 @with_environment
 def test_get_home_dir_3():
     """get_home_dir() uses $HOME if set"""
     env["HOME"] = HOME_TEST_DIR
     home_dir = path.get_home_dir(True)
     # get_home_dir expands symlinks
     nt.assert_equal(home_dir, os.path.realpath(env["HOME"]))
 
 
 @with_environment
 def test_get_home_dir_4():
     """get_home_dir() still works if $HOME is not set"""
 
     if 'HOME' in env: del env['HOME']
     # this should still succeed, but we don't care what the answer is
     home = path.get_home_dir(False)
 
 @with_environment
 def test_get_home_dir_5():
     """raise HomeDirError if $HOME is specified, but not a writable dir"""
     env['HOME'] = abspath(HOME_TEST_DIR+'garbage')
     # set os.name = posix, to prevent My Documents fallback on Windows
     os.name = 'posix'
     nt.assert_raises(path.HomeDirError, path.get_home_dir, True)
 
 
 # Should we stub wreg fully so we can run the test on all platforms?
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_8():
     """Using registry hack for 'My Documents', os=='nt'
 
     HOMESHARE, HOMEDRIVE, HOMEPATH, USERPROFILE and others are missing.
     """
     os.name = 'nt'
     # Remove from stub environment all keys that may be set
     for key in ['HOME', 'HOMESHARE', 'HOMEDRIVE', 'HOMEPATH', 'USERPROFILE']:
         env.pop(key, None)
 
     #Stub windows registry functions
     def OpenKey(x, y):
         class key:
             def Close(self):
                 pass
         return key()
     def QueryValueEx(x, y):
         return [abspath(HOME_TEST_DIR)]
 
     wreg.OpenKey = OpenKey
     wreg.QueryValueEx = QueryValueEx
 
     home_dir = path.get_home_dir()
     nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
 
 
 @with_environment
 def test_get_ipython_dir_1():
     """test_get_ipython_dir_1, Testcase to see if we can call get_ipython_dir without Exceptions."""
     env_ipdir = os.path.join("someplace", ".ipython")
     path._writable_dir = lambda path: True
     env['IPYTHONDIR'] = env_ipdir
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, env_ipdir)
 
 
 @with_environment
 def test_get_ipython_dir_2():
     """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions."""
     path.get_home_dir = lambda : "someplace"
     path.get_xdg_dir = lambda : None
     path._writable_dir = lambda path: True
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, os.path.join("someplace", ".ipython"))
 
 @with_environment
 def test_get_ipython_dir_3():
     """test_get_ipython_dir_3, use XDG if defined, and .ipython doesn't exist."""
     path.get_home_dir = lambda : "someplace"
     path._writable_dir = lambda path: True
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
     ipdir = path.get_ipython_dir()
     if sys.platform == "darwin":
         expected = os.path.join("someplace", ".ipython")
     else:
         expected = os.path.join(XDG_TEST_DIR, "ipython")
     nt.assert_equal(ipdir, expected)
 
 @with_environment
 def test_get_ipython_dir_4():
     """test_get_ipython_dir_4, use XDG if both exist."""
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
     ipdir = path.get_ipython_dir()
     if sys.platform == "darwin":
         expected = os.path.join(HOME_TEST_DIR, ".ipython")
     else:
         expected = os.path.join(XDG_TEST_DIR, "ipython")
     nt.assert_equal(ipdir, expected)
 
 @with_environment
 def test_get_ipython_dir_5():
     """test_get_ipython_dir_5, use .ipython if exists and XDG defined, but doesn't exist."""
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
     os.rmdir(os.path.join(XDG_TEST_DIR, 'ipython'))
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, IP_TEST_DIR)
 
 @with_environment
 def test_get_ipython_dir_6():
     """test_get_ipython_dir_6, use XDG if defined and neither exist."""
     xdg = os.path.join(HOME_TEST_DIR, 'somexdg')
     os.mkdir(xdg)
     shutil.rmtree(os.path.join(HOME_TEST_DIR, '.ipython'))
     path.get_home_dir = lambda : HOME_TEST_DIR
     path.get_xdg_dir = lambda : xdg
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     xdg_ipdir = os.path.join(xdg, "ipython")
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, xdg_ipdir)
 
 @with_environment
 def test_get_ipython_dir_7():
     """test_get_ipython_dir_7, test home directory expansion on IPYTHONDIR"""
     path._writable_dir = lambda path: True
     home_dir = os.path.normpath(os.path.expanduser('~'))
     env['IPYTHONDIR'] = os.path.join('~', 'somewhere')
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, os.path.join(home_dir, 'somewhere'))
 
 @skip_win32
 @with_environment
 def test_get_ipython_dir_8():
     """test_get_ipython_dir_8, test / home directory"""
     old = path._writable_dir, path.get_xdg_dir
     try:
         path._writable_dir = lambda path: bool(path)
         path.get_xdg_dir = lambda: None
         env.pop('IPYTHON_DIR', None)
         env.pop('IPYTHONDIR', None)
         env['HOME'] = '/'
         nt.assert_equal(path.get_ipython_dir(), '/.ipython')
     finally:
         path._writable_dir, path.get_xdg_dir = old
 
 @with_environment
 def test_get_xdg_dir_0():
     """test_get_xdg_dir_0, check xdg_dir"""
     reload(path)
     path._writable_dir = lambda path: True
     path.get_home_dir = lambda : 'somewhere'
     os.name = "posix"
     sys.platform = "linux2"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
 
     nt.assert_equal(path.get_xdg_dir(), os.path.join('somewhere', '.config'))
 
 
 @with_environment
 def test_get_xdg_dir_1():
     """test_get_xdg_dir_1, check nonexistant xdg_dir"""
     reload(path)
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     sys.platform = "linux2"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     nt.assert_equal(path.get_xdg_dir(), None)
 
 @with_environment
 def test_get_xdg_dir_2():
     """test_get_xdg_dir_2, check xdg_dir default to ~/.config"""
     reload(path)
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     sys.platform = "linux2"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     cfgdir=os.path.join(path.get_home_dir(), '.config')
     if not os.path.exists(cfgdir):
         os.makedirs(cfgdir)
 
     nt.assert_equal(path.get_xdg_dir(), cfgdir)
 
 @with_environment
 def test_get_xdg_dir_3():
     """test_get_xdg_dir_3, check xdg_dir not used on OS X"""
     reload(path)
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     sys.platform = "darwin"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     cfgdir=os.path.join(path.get_home_dir(), '.config')
     if not os.path.exists(cfgdir):
         os.makedirs(cfgdir)
 
     nt.assert_equal(path.get_xdg_dir(), None)
 
 def test_filefind():
     """Various tests for filefind"""
     f = tempfile.NamedTemporaryFile()
     # print 'fname:',f.name
     alt_dirs = path.get_ipython_dir()
     t = path.filefind(f.name, alt_dirs)
     # print 'found:',t
 
 @with_environment
 def test_get_ipython_cache_dir():
     os.environ["HOME"] = HOME_TEST_DIR
     if os.name == 'posix' and sys.platform != 'darwin':
         # test default
         os.makedirs(os.path.join(HOME_TEST_DIR, ".cache"))
         os.environ.pop("XDG_CACHE_HOME", None)
         ipdir = path.get_ipython_cache_dir()
         nt.assert_equal(os.path.join(HOME_TEST_DIR, ".cache", "ipython"),
                         ipdir)
         nt.assert_true(os.path.isdir(ipdir))
 
         # test env override
         os.environ["XDG_CACHE_HOME"] = XDG_CACHE_DIR
         ipdir = path.get_ipython_cache_dir()
         nt.assert_true(os.path.isdir(ipdir))
         nt.assert_equal(ipdir, os.path.join(XDG_CACHE_DIR, "ipython"))
     else:
         nt.assert_equal(path.get_ipython_cache_dir(),
                         path.get_ipython_dir())
 
 def test_get_ipython_package_dir():
     ipdir = path.get_ipython_package_dir()
     nt.assert_true(os.path.isdir(ipdir))
 
 
 def test_get_ipython_module_path():
-    ipapp_path = path.get_ipython_module_path('IPython.frontend.terminal.ipapp')
+    ipapp_path = path.get_ipython_module_path('IPython.terminal.ipapp')
     nt.assert_true(os.path.isfile(ipapp_path))
 
 
 @dec.skip_if_not_win32
 def test_get_long_path_name_win32():
     p = path.get_long_path_name('c:\\docume~1')
     nt.assert_equal(p,u'c:\\Documents and Settings')
 
 
 @dec.skip_win32
 def test_get_long_path_name():
     p = path.get_long_path_name('/usr/local')
     nt.assert_equal(p,'/usr/local')
 
 @dec.skip_win32 # can't create not-user-writable dir on win
 @with_environment
 def test_not_writable_ipdir():
     tmpdir = tempfile.mkdtemp()
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     env['HOME'] = tmpdir
     ipdir = os.path.join(tmpdir, '.ipython')
     os.mkdir(ipdir)
     os.chmod(ipdir, 600)
     with AssertPrints('is not a writable location', channel='stderr'):
         ipdir = path.get_ipython_dir()
     env.pop('IPYTHON_DIR', None)
 
 def test_unquote_filename():
     for win32 in (True, False):
         nt.assert_equal(path.unquote_filename('foo.py', win32=win32), 'foo.py')
         nt.assert_equal(path.unquote_filename('foo bar.py', win32=win32), 'foo bar.py')
     nt.assert_equal(path.unquote_filename('"foo.py"', win32=True), 'foo.py')
     nt.assert_equal(path.unquote_filename('"foo bar.py"', win32=True), 'foo bar.py')
     nt.assert_equal(path.unquote_filename("'foo.py'", win32=True), 'foo.py')
     nt.assert_equal(path.unquote_filename("'foo bar.py'", win32=True), 'foo bar.py')
     nt.assert_equal(path.unquote_filename('"foo.py"', win32=False), '"foo.py"')
     nt.assert_equal(path.unquote_filename('"foo bar.py"', win32=False), '"foo bar.py"')
     nt.assert_equal(path.unquote_filename("'foo.py'", win32=False), "'foo.py'")
     nt.assert_equal(path.unquote_filename("'foo bar.py'", win32=False), "'foo bar.py'")
 
 @with_environment
 def test_get_py_filename():
     os.chdir(TMP_TEST_DIR)
     for win32 in (True, False):
         with make_tempfile('foo.py'):
             nt.assert_equal(path.get_py_filename('foo.py', force_win32=win32), 'foo.py')
             nt.assert_equal(path.get_py_filename('foo', force_win32=win32), 'foo.py')
         with make_tempfile('foo'):
             nt.assert_equal(path.get_py_filename('foo', force_win32=win32), 'foo')
             nt.assert_raises(IOError, path.get_py_filename, 'foo.py', force_win32=win32)
         nt.assert_raises(IOError, path.get_py_filename, 'foo', force_win32=win32)
         nt.assert_raises(IOError, path.get_py_filename, 'foo.py', force_win32=win32)
         true_fn = 'foo with spaces.py'
         with make_tempfile(true_fn):
             nt.assert_equal(path.get_py_filename('foo with spaces', force_win32=win32), true_fn)
             nt.assert_equal(path.get_py_filename('foo with spaces.py', force_win32=win32), true_fn)
             if win32:
                 nt.assert_equal(path.get_py_filename('"foo with spaces.py"', force_win32=True), true_fn)
                 nt.assert_equal(path.get_py_filename("'foo with spaces.py'", force_win32=True), true_fn)
             else:
                 nt.assert_raises(IOError, path.get_py_filename, '"foo with spaces.py"', force_win32=False)
                 nt.assert_raises(IOError, path.get_py_filename, "'foo with spaces.py'", force_win32=False)
                 
 def test_unicode_in_filename():
     """When a file doesn't exist, the exception raised should be safe to call
     str() on - i.e. in Python 2 it must only have ASCII characters.
     
     https://github.com/ipython/ipython/issues/875
     """
     try:
         # these calls should not throw unicode encode exceptions
         path.get_py_filename(u'fooéè.py',  force_win32=False)
     except IOError as ex:
         str(ex)
 
 
 class TestShellGlob(object):
 
     @classmethod
     def setUpClass(cls):
         cls.filenames_start_with_a = map('a{0}'.format, range(3))
         cls.filenames_end_with_b = map('{0}b'.format, range(3))
         cls.filenames = cls.filenames_start_with_a + cls.filenames_end_with_b
         cls.tempdir = TemporaryDirectory()
         td = cls.tempdir.name
 
         with cls.in_tempdir():
             # Create empty files
             for fname in cls.filenames:
                 open(os.path.join(td, fname), 'w').close()
 
     @classmethod
     def tearDownClass(cls):
         cls.tempdir.cleanup()
 
     @classmethod
     @contextmanager
     def in_tempdir(cls):
         save = os.getcwdu()
         try:
             os.chdir(cls.tempdir.name)
             yield
         finally:
             os.chdir(save)
 
     def check_match(self, patterns, matches):
         with self.in_tempdir():
             # glob returns unordered list. that's why sorted is required.
             nt.assert_equals(sorted(path.shellglob(patterns)),
                              sorted(matches))
 
     def common_cases(self):
         return [
             (['*'], self.filenames),
             (['a*'], self.filenames_start_with_a),
             (['*c'], ['*c']),
             (['*', 'a*', '*b', '*c'], self.filenames
                                       + self.filenames_start_with_a
                                       + self.filenames_end_with_b
                                       + ['*c']),
             (['a[012]'], self.filenames_start_with_a),
         ]
 
     @skip_win32
     def test_match_posix(self):
         for (patterns, matches) in self.common_cases() + [
                 ([r'\*'], ['*']),
                 ([r'a\*', 'a*'], ['a*'] + self.filenames_start_with_a),
                 ([r'a\[012]'], ['a[012]']),
                 ]:
             yield (self.check_match, patterns, matches)
 
     @skip_if_not_win32
     def test_match_windows(self):
         for (patterns, matches) in self.common_cases() + [
                 # In windows, backslash is interpreted as path
                 # separator.  Therefore, you can't escape glob
                 # using it.
                 ([r'a\*', 'a*'], [r'a\*'] + self.filenames_start_with_a),
                 ([r'a\[012]'], [r'a\[012]']),
                 ]:
             yield (self.check_match, patterns, matches)
 
 
 def test_unescape_glob():
     nt.assert_equals(path.unescape_glob(r'\*\[\!\]\?'), '*[!]?')
     nt.assert_equals(path.unescape_glob(r'\\*'), r'\*')
     nt.assert_equals(path.unescape_glob(r'\\\*'), r'\*')
     nt.assert_equals(path.unescape_glob(r'\\a'), r'\a')
     nt.assert_equals(path.unescape_glob(r'\a'), r'\a')

MANIFEST.in

@@ -1,39 +1,39 b''
 include README.rst
 include COPYING.txt
 include setupbase.py
 include setupegg.py
 
 graft setupext
 
 graft scripts
 
 # Load main dir but exclude things we don't want in the distro
 graft IPython
 prune IPython/deathrow
 prune IPython/external/js
-prune IPython/frontend/html/notebook/static/mathjax
+prune IPython/html/static/mathjax
 
 # Include some specific files and data resources we need
 include IPython/.git_commit_info.ini
-include IPython/frontend/qt/console/resources/icon/IPythonConsole.svg
+include IPython/qt/console/resources/icon/IPythonConsole.svg
 
 # Documentation
 graft docs
 exclude docs/\#*
 exclude docs/man/*.1.gz
 
 # Examples
 graft examples
 
 # docs subdirs we want to skip
 prune docs/attic
 prune docs/build
 prune docs/gh-pages
 prune docs/dist
 
 # Patterns to exclude from any directory
 global-exclude *~
 global-exclude *.flc
 global-exclude *.pyc
 global-exclude *.pyo
 global-exclude .dircopy.log

docs/source/interactive/htmlnotebook.txt

@@ -1,482 +1,482 b''
 .. _htmlnotebook:
 
 =========================
 An HTML Notebook IPython
 =========================
 
 .. seealso::
 
     :ref:`Installation requirements <installnotebook>` for the Notebook.
 
 The IPython Notebook consists of two related components:
 
 * An JSON based Notebook document format for recording and distributing
   Python code and rich text.
 * A web-based user interface for authoring and running notebook documents.
 
 The Notebook can be used by starting the Notebook server with the 
 command::
 
     $ ipython notebook
 
 Note that by default, the notebook doesn't load pylab, it's just a normal
 IPython session like any other.  If you want pylab support, you must use::
     
     $ ipython notebook --pylab
 
 which will behave similar to the terminal and Qt console versions, using your
 default matplotlib backend and providing floating interactive plot windows.  If
 you want inline figures, you must manually select the ``inline`` backend::
 
     $ ipython notebook --pylab inline
 
 This server uses the same ZeroMQ-based two process kernel architecture as
 the QT Console as well Tornado for serving HTTP/S requests. Some of the main
 features of the Notebook include:
 
 * Display rich data (png/html/latex/svg) in the browser as a result of
   computations.
 * Compose text cells using HTML and Markdown.
 * Import and export notebook documents in range of formats (.ipynb, .py).
 * In browser syntax highlighting, tab completion and autoindentation.
 * Inline matplotlib plots that can be stored in Notebook documents and opened
   later.
 
 See :ref:`our installation documentation <install_index>` for directions on
 how to install the notebook and its dependencies.
 
 .. note::
 
    You can start more than one notebook server at the same time, if you want to
    work on notebooks in different directories.  By default the first notebook
    server starts in port 8888, later notebooks search for random ports near
    that one.  You can also manually specify the port with the ``--port``
    option.
    
 
 Basic Usage
 ===========
 
 The landing page of the notebook server application, which we call the IPython
 Notebook *dashboard*, shows the notebooks currently available in the directory
 in which the application was started, and allows you to create new notebooks.
 
 A notebook is a combination of two things:
 
 1. An interactive session connected to an IPython kernel, controlled by a web
    application that can send input to the console and display many types of
    output (text, graphics, mathematics and more).  This is the same kernel used
    by the :ref:`Qt console <qtconsole>`, but in this case the web console sends
    input in persistent cells that you can edit in-place instead of the
    vertically scrolling terminal style used by the Qt console.
 
 2. A document that can save the inputs and outputs of the session as well as
    additional text that accompanies the code but is not meant for execution.
    In this way, notebook files serve as a complete computational record of a
    session including explanatory text and mathematics, code and resulting
    figures.  These documents are internally JSON files and are saved with the
    ``.ipynb`` extension.
 
 If you have ever used the Mathematica or Sage notebooks (the latter is also
 web-based__) you should feel right at home.  If you have not, you should be
 able to learn how to use it in just a few minutes.
 
 .. __: http://sagenb.org
 
 
 Creating and editing notebooks
 ------------------------------
 
 You can create new notebooks from the dashboard with the ``New Notebook``
 button or open existing ones by clicking on their name.  Once in a notebook,
 your browser tab will reflect the name of that notebook (prefixed with "IPy:").
 The URL for that notebook is not meant to be human-readable and is *not*
 persistent across invocations of the notebook server.
 
 You can also drag and drop into the area listing files any python file: it
 will be imported into a notebook with the same name (but ``.ipynb`` extension)
 located in the directory where the notebook server was started.  This notebook
 will consist of a single cell with all the code in the file, which you can
 later manually partition into individual cells for gradual execution, add text
 and graphics, etc.
 
 
 Workflow and limitations
 ------------------------
 
 The normal workflow in a notebook is quite similar to a normal IPython session,
 with the difference that you can edit a cell in-place multiple times until you
 obtain the desired results rather than having to rerun separate scripts with
 the ``%run`` magic (though magics also work in the notebook).   Typically
 you'll work on a problem in pieces, organizing related pieces into cells and
 moving forward as previous parts work correctly.  This is much more convenient
 for interactive exploration than breaking up a computation into scripts that
 must be executed together, especially if parts of them take a long time to run
 (In the traditional terminal-based IPython, you can use tricks with namespaces
 and ``%run -i`` to achieve this capability, but we think the notebook is a more
 natural solution for  that kind of problem).
 
 The only significant limitation the notebook currently has, compared to the qt
 console, is that it can not run any code that expects input from the kernel
 (such as scripts that call :func:`raw_input`).  Very importantly, this means
 that the ``%debug`` magic does *not* work in the notebook!  We intend to
 correct this limitation, but in the meantime, there is a way to debug problems
 in the notebook: you can attach a Qt console to your existing notebook kernel,
 and run ``%debug`` from the Qt console.  If your notebook is running on a local
 computer (i.e. if you are accessing it via your localhost address at
 127.0.0.1), you can just type ``%qtconsole`` in the notebook and a Qt console
 will open up connected to that same kernel.
 
 In general, the notebook server prints the full details of how to connect to
 each kernel at the terminal, with lines like::
 
     [IPKernelApp] To connect another client to this kernel, use:
     [IPKernelApp] --existing kernel-3bb93edd-6b5a-455c-99c8-3b658f45dde5.json
 
 This is the name of a JSON file that contains all the port and validation
 information necessary to connect to the kernel.  You can manually start a
 qt console with::
 
     ipython qtconsole --existing kernel-3bb93edd-6b5a-455c-99c8-3b658f45dde5.json
 
 and if you only have a single kernel running, simply typing::
 
     ipython qtconsole --existing
 
 will automatically find it (it will always find the most recently started
 kernel if there is more than one).  You can also request this connection data
 by typing ``%connect_info``; this will print the same file information as well
 as the content of the JSON data structure it contains.
 
     
 Text input
 ----------
 
 In addition to code cells and the output they produce (such as figures), you
 can also type text not meant for execution.  To type text, change the type of a
 cell from ``Code`` to ``Markdown`` by using the button or the :kbd:`Ctrl-m m`
 keybinding (see below).  You can then type any text in Markdown_ syntax, as
 well as mathematical expressions if you use ``$...$`` for inline math or
 ``$$...$$`` for displayed math.
 
 
 Exporting a notebook and importing existing scripts
 ---------------------------------------------------
 
 If you want to provide others with a static HTML or PDF view of your notebook,
 use the ``Print`` button.  This opens a static view of the document, which you
 can print to PDF using your operating system's facilities, or save to a file
 with your web browser's 'Save' option (note that typically, this will create
 both an html file *and* a directory called `notebook_name_files` next to it
 that contains all the necessary style information, so if you intend to share
 this, you must send the directory along with the main html file).
 
 The `Download` button lets you save a notebook file to the Download area
 configured by your web browser (particularly useful if you are running the
 notebook server on a remote host and need a file locally).  The notebook is
 saved by default with the ``.ipynb`` extension and the files contain JSON data
 that is not meant for human editing or consumption.  But you can always export
 the input part of a notebook to a plain python script by choosing Python format
 in the `Download` drop list.  This removes all output and saves the text cells
 in comment areas.  See ref:`below <notebook_format>` for more details on the
 notebook format.
 
 The notebook can also *import* ``.py`` files as notebooks, by dragging and
 dropping the file into the notebook dashboard file list area.  By default, the
 entire contents of the file will be loaded into a single code cell.  But if
 prior to import, you manually add the ``# <nbformat>2</nbformat>`` marker at
 the start and then add separators for text/code cells, you can get a cleaner
 import with the file broken into individual cells.
     
 .. warning::
 
    While in simple cases you can roundtrip a notebook to Python, edit the
    python file and import it back without loss of main content, this is in
    general *not guaranteed to work at all*.  First, there is extra metadata
    saved in the notebook that may not be saved to the ``.py`` format.  And as
    the notebook format evolves in complexity, there will be attributes of the
    notebook that will not survive a roundtrip through the Python form.  You
    should think of the Python format as a way to output a script version of a
    notebook and the import capabilities as a way to load existing code to get a
    notebook started.  But the Python version is *not* an alternate notebook
    format.
 
    
 Importing or executing a notebook as a normal Python file
 ---------------------------------------------------------
 
 The native format of the notebook, a file with a ``.ipynb`` extension, is a
 JSON container of all the input and output of the notebook, and therefore not
 valid Python by itself.  This means that by default, you can not import a
 notebook or execute it as a normal python script.  But if you want use
 notebooks as regular Python files, you can start the notebook server with::
 
   ipython notebook --script
 
 or you can set this option permanently in your configuration file with::
 
     c.NotebookManager.save_script=True
 
 This will instruct the notebook server to save the ``.py`` export of each
 notebook adjacent to the ``.ipynb`` at every save.  These files can be
 ``%run``, imported from regular IPython sessions or other notebooks, or
 executed at the command-line as normal Python files.  Since we export the raw
 code you have typed, for these files to be importable from other code you will
 have to avoid using syntax such as ``%magics`` and other IPython-specific
 extensions to the language.
 
 In regular practice, the standard way to differentiate importable code from the
 'executable' part of a script is to put at the bottom::
 
   if __name__ == '__main__':
     # rest of the code...
 
 Since all cells in the notebook are run as top-level code, you'll need to
 similarly protect *all* cells that you do not want executed when other scripts
 try to import your notebook.  A convenient shortand for this is to define early
 on::
 
   script = __name__ == '__main__'
 
 and then on any cell that you need to protect, use::
 
   if script:
     # rest of the cell...
 
 Configuration
 -------------
 
 The IPython notebook server can be run with a variety of command line arguments. 
 To see a list of available options enter:
 
   $ ipython notebook --help 
 
 Defaults for these options can also be set by creating a file named 
 ipython_notebook_config.py in your IPython profile folder. The profile folder is
 a subfolder of your IPython directory (`ipython locate` will show you where that
 is). To create default configuration files (with lots of info on available 
 options) use:
 
   $ ipython profile create
 
 .. seealso:
 
     :ref:`config_overview`, in particular :ref:`Profiles`.
 
 
 Keyboard use
 ------------
 
 All actions in the notebook can be achieved with the mouse, but we have also
 added keyboard shortcuts for the most common ones, so that productive use of
 the notebook can be achieved with minimal mouse intervention.  The main
 key bindings you need to remember are:
 
 * :kbd:`Shift-Enter`: execute the current cell (similar to the Qt console),
   show output (if any) and jump to the next cell below. If :kbd:`Shift-Enter` 
   was invoked on the last input line, a new code cell will also be created. Note 
   that in the notebook, simply using :kbd:`Enter` *never* forces execution, 
   it simply inserts a new line in the current cell. Therefore, in the notebook 
   you must always use :kbd:`Shift-Enter` to get execution (or use the mouse and 
   click on the ``Run Selected`` button).
 
 * :kbd:`Alt-Enter`: this combination is similar to the previous one, with the 
   exception that, if the next cell below is not empty, a new code cell will be 
   added to the notebook, even if the cell execution happens not in the last cell. 
   In this regard, :kbd:`Alt-Enter`: is simply a shortcut for the :kbd:`Shift-Enter`, 
   :kbd:`Ctrl-m a` sequence. 
   
 * :kbd:`Ctrl-Enter`: execute the current cell in "terminal mode", where any
   output is shown but the cursor stays in the current cell, whose input
   area is flushed empty.  This is convenient to do quick in-place experiments
   or query things like filesystem content without creating additional cells you
   may not want saved in your notebook.
 
 * :kbd:`Ctrl-m`: this is the prefix for all other keybindings, which consist
   of an additional single letter.  Type :kbd:`Ctrl-m h` (that is, the sole
   letter :kbd:`h` after :kbd:`Ctrl-m`) and IPython will show you the remaining
   available keybindings.
 
 
 .. _notebook_security:
 
 Security
 ========
 
 You can protect your notebook server with a simple single-password by
 setting the :attr:`NotebookApp.password` configurable. You can prepare a
 hashed password using the function :func:`IPython.lib.security.passwd`:
 
 .. sourcecode:: ipython
 
     In [1]: from IPython.lib import passwd
     In [2]: passwd()
     Enter password: 
     Verify password: 
     Out[2]: 'sha1:67c9e60bb8b6:9ffede0825894254b2e042ea597d771089e11aed'
     
 .. note::
 
   :func:`~IPython.lib.security.passwd` can also take the password as a string
   argument. **Do not** pass it as an argument inside an IPython session, as it
   will be saved in your input history.
 
 You can then add this to your :file:`ipython_notebook_config.py`, e.g.::
 
     # Password to use for web authentication
     c.NotebookApp.password = u'sha1:67c9e60bb8b6:9ffede0825894254b2e042ea597d771089e11aed'
 
 When using a password, it is a good idea to also use SSL, so that your password
 is not sent unencrypted by your browser. You can start the notebook to
 communicate via a secure protocol mode using a self-signed certificate by
 typing::
 
     $ ipython notebook --certfile=mycert.pem
 
 .. note::
 
     A self-signed certificate can be generated with openssl.  For example, the
     following command will create a certificate valid for 365 days with both
     the key and certificate data written to the same file::
 
         $ openssl req -x509 -nodes -days 365 -newkey rsa:1024 -keyout mycert.pem -out mycert.pem
 
 Your browser will warn you of a dangerous certificate because it is
 self-signed.  If you want to have a fully compliant certificate that will not
 raise warnings, it is possible (but rather involved) to obtain one for free,
 `as explained in detailed in this tutorial`__.
 
 .. __: http://arstechnica.com/security/news/2009/12/how-to-get-set-with-a-secure-sertificate-for-free.ars
 	
 Keep in mind that when you enable SSL support, you'll need to access the
 notebook server over ``https://``, not over plain ``http://``.  The startup
 message from the server prints this, but it's easy to overlook and think the
 server is for some reason non-responsive.
 
 Quick how to's
 ==============
 
 Running a public notebook server
 --------------------------------
 
 If you want to access your notebook server remotely with just a web browser,
 here is a quick set of instructions.  Start by creating a certificate file and
 a hashed password as explained above.  Then, create a custom profile for the
 notebook.  At the command line, type::
 
   ipython profile create nbserver
 
 In the profile directory, edit the file ``ipython_notebook_config.py``.  By
 default the file has all fields commented, the minimum set you need to
 uncomment and edit is here::
 
      c = get_config()
 
      # Kernel config
      c.IPKernelApp.pylab = 'inline'  # if you want plotting support always
 
      # Notebook config
      c.NotebookApp.certfile = u'/absolute/path/to/your/certificate/mycert.pem'
      c.NotebookApp.ip = '*'
      c.NotebookApp.open_browser = False
      c.NotebookApp.password = u'sha1:bcd259ccf...your hashed password here'
      # It's a good idea to put it on a known, fixed port
      c.NotebookApp.port = 9999
 
 You can then start the notebook and access it later by pointing your browser to
 ``https://your.host.com:9999`` with ``ipython notebook --profile=nbserver``.
 
 Running with a different URL prefix
 -----------------------------------
 
 The notebook dashboard (i.e. the default landing page with an overview
 of all your notebooks) typically lives at a URL path of
 "http://localhost:8888/". If you want to have it, and the rest of the
 notebook, live under a sub-directory,
 e.g. "http://localhost:8888/ipython/", you can do so with
 configuration options like these (see above for instructions about
 modifying ``ipython_notebook_config.py``)::
 
     c.NotebookApp.base_project_url = '/ipython/'
     c.NotebookApp.base_kernel_url = '/ipython/'
     c.NotebookApp.webapp_settings = {'static_url_prefix':'/ipython/static/'}
 
 Using a different notebook store
 --------------------------------
 
 By default the notebook server stores notebooks as files in the working 
 directory of the notebook server, also known as the ``notebook_dir``. This 
 logic is implemented in the :class:`FileNotebookManager` class. However, the 
 server can be configured to use a different notebook manager class, which can 
 store the notebooks in a different format. Currently, we ship a 
 :class:`AzureNotebookManager` class that stores notebooks in Azure blob 
 storage. This can be used by adding the following lines to your 
 ``ipython_notebook_config.py`` file::
 
-    c.NotebookApp.notebook_manager_class = 'IPython.frontend.html.notebook.azurenbmanager.AzureNotebookManager'
+    c.NotebookApp.notebook_manager_class = 'IPython.html.services.notebooks.azurenbmanager.AzureNotebookManager'
     c.AzureNotebookManager.account_name = u'paste_your_account_name_here'
     c.AzureNotebookManager.account_key = u'paste_your_account_key_here'
     c.AzureNotebookManager.container = u'notebooks'
 
 In addition to providing your Azure Blob Storage account name and key, you will 
 have to provide a container name; you can use multiple containers to organize 
 your Notebooks.
 
 .. _notebook_format:
 
 The notebook format
 ===================
 
 The notebooks themselves are JSON files with an ``ipynb`` extension, formatted
 as legibly as possible with minimal extra indentation and cell content broken
 across lines to make them reasonably friendly to use in version-control
 workflows.  You should be very careful if you ever edit manually this JSON
 data, as it is extremely easy to corrupt its internal structure and make the
 file impossible to load.  In general, you should consider the notebook as a
 file meant only to be edited by IPython itself, not for hand-editing.
 
 .. note::
 
      Binary data such as figures are directly saved in the JSON file.  This
      provides convenient single-file portability but means the files can be
      large and diffs of binary data aren't very meaningful.  Since the binary
      blobs are encoded in a single line they only affect one line of the diff
      output, but they are typically very long lines.  You can use the
      'ClearAll' button to remove all output from a notebook prior to
      committing it to version control, if this is a concern.
 
 The notebook server can also generate a pure-python version of your notebook,
 by clicking on the 'Download' button and selecting ``py`` as the format.  This
 file will contain all the code cells from your notebook verbatim, and all text
 cells prepended with a comment marker.  The separation between code and text
 cells is indicated with special comments and there is a header indicating the
 format version.  All output is stripped out when exporting to python.
 
 Here is an example of a simple notebook with one text cell and one code input
 cell, when exported to python format::
 
     # <nbformat>2</nbformat>
 
     # <markdowncell>
 
     # A text cell
 
     # <codecell>
 
     print "hello IPython"
 
 
 Known issues
 ============
 
 When behind a proxy, especially if your system or browser is set to autodetect
 the proxy, the html notebook might fail to connect to the server's websockets,
 and present you with a warning at startup. In this case, you need to configure
 your system not to use the proxy for the server's address.
 
 In Firefox, for example, go to the Preferences panel, Advanced section,
 Network tab, click 'Settings...', and add the address of the notebook server
 to the 'No proxy for' field.
 
     
 .. _Markdown: http://daringfireball.net/projects/markdown/basics

setupbase.py

@@ -1,468 +1,468 b''
 # encoding: utf-8
 """
 This module defines the things that are used in setup.py for building IPython
 
 This includes:
 
     * The basic arguments to setup
     * Functions for finding things like packages, package data, etc.
     * A function for checking dependencies.
 """
 from __future__ import print_function
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  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 os
 import sys
 
 try:
     from configparser import ConfigParser
 except:
     from ConfigParser import ConfigParser
 from distutils.command.build_py import build_py
 from distutils.cmd import Command
 from glob import glob
 
 from setupext import install_data_ext
 
 #-------------------------------------------------------------------------------
 # Useful globals and utility functions
 #-------------------------------------------------------------------------------
 
 # A few handy globals
 isfile = os.path.isfile
 pjoin = os.path.join
 repo_root = os.path.dirname(os.path.abspath(__file__))
 
 def oscmd(s):
     print(">", s)
     os.system(s)
 
 # Py3 compatibility hacks, without assuming IPython itself is installed with
 # the full py3compat machinery.
 
 try:
     execfile
 except NameError:
     def execfile(fname, globs, locs=None):
         locs = locs or globs
         exec(compile(open(fname).read(), fname, "exec"), globs, locs)
 
 # A little utility we'll need below, since glob() does NOT allow you to do
 # exclusion on multiple endings!
 def file_doesnt_endwith(test,endings):
     """Return true if test is a file and its name does NOT end with any
     of the strings listed in endings."""
     if not isfile(test):
         return False
     for e in endings:
         if test.endswith(e):
             return False
     return True
 
 #---------------------------------------------------------------------------
 # Basic project information
 #---------------------------------------------------------------------------
 
 # release.py contains version, authors, license, url, keywords, etc.
 execfile(pjoin(repo_root, 'IPython','core','release.py'), globals())
 
 # Create a dict with the basic information
 # This dict is eventually passed to setup after additional keys are added.
 setup_args = dict(
       name             = name,
       version          = version,
       description      = description,
       long_description = long_description,
       author           = author,
       author_email     = author_email,
       url              = url,
       download_url     = download_url,
       license          = license,
       platforms        = platforms,
       keywords         = keywords,
       classifiers      = classifiers,
       cmdclass         = {'install_data': install_data_ext},
       )
 
 
 #---------------------------------------------------------------------------
 # Find packages
 #---------------------------------------------------------------------------
 
 def find_packages():
     """
     Find all of IPython's packages.
     """
     excludes = ['deathrow', 'quarantine']
     packages = []
     for dir,subdirs,files in os.walk('IPython'):
         package = dir.replace(os.path.sep, '.')
         if any(package.startswith('IPython.'+exc) for exc in excludes):
             # package is to be excluded (e.g. deathrow)
             continue
         if '__init__.py' not in files:
             # not a package
             continue
         packages.append(package)
     return packages
 
 #---------------------------------------------------------------------------
 # Find package data
 #---------------------------------------------------------------------------
 
 def find_package_data():
     """
     Find IPython's package_data.
     """
     # This is not enough for these things to appear in an sdist.
     # We need to muck with the MANIFEST to get this to work
     
     # exclude static things that we don't ship (e.g. mathjax)
     excludes = ['mathjax']
     
     # add 'static/' prefix to exclusions, and tuplify for use in startswith
     excludes = tuple([os.path.join('static', ex) for ex in excludes])
     
     # walk notebook resources:
     cwd = os.getcwd()
-    os.chdir(os.path.join('IPython', 'frontend', 'html', 'notebook'))
+    os.chdir(os.path.join('IPython', 'html'))
     static_walk = list(os.walk('static'))
     os.chdir(cwd)
     static_data = []
     for parent, dirs, files in static_walk:
         if parent.startswith(excludes):
             continue
         for f in files:
             static_data.append(os.path.join(parent, f))
 
     package_data = {
         'IPython.config.profile' : ['README*', '*/*.py'],
         'IPython.testing' : ['*.txt'],
         'IPython.testing.plugin' : ['*.txt'],
-        'IPython.frontend.html.notebook' : ['templates/*'] + static_data,
-        'IPython.frontend.qt.console' : ['resources/icon/*.svg'],
+        'IPython.html' : ['templates/*'] + static_data,
+        'IPython.qt.console' : ['resources/icon/*.svg'],
     }
     return package_data
 
 
 #---------------------------------------------------------------------------
 # Find data files
 #---------------------------------------------------------------------------
 
 def make_dir_struct(tag,base,out_base):
     """Make the directory structure of all files below a starting dir.
 
     This is just a convenience routine to help build a nested directory
     hierarchy because distutils is too stupid to do this by itself.
 
     XXX - this needs a proper docstring!
     """
 
     # we'll use these a lot below
     lbase = len(base)
     pathsep = os.path.sep
     lpathsep = len(pathsep)
 
     out = []
     for (dirpath,dirnames,filenames) in os.walk(base):
         # we need to strip out the dirpath from the base to map it to the
         # output (installation) path.  This requires possibly stripping the
         # path separator, because otherwise pjoin will not work correctly
         # (pjoin('foo/','/bar') returns '/bar').
 
         dp_eff = dirpath[lbase:]
         if dp_eff.startswith(pathsep):
             dp_eff = dp_eff[lpathsep:]
         # The output path must be anchored at the out_base marker
         out_path = pjoin(out_base,dp_eff)
         # Now we can generate the final filenames. Since os.walk only produces
         # filenames, we must join back with the dirpath to get full valid file
         # paths:
         pfiles = [pjoin(dirpath,f) for f in filenames]
         # Finally, generate the entry we need, which is a pari of (output
         # path, files) for use as a data_files parameter in install_data.
         out.append((out_path, pfiles))
 
     return out
 
 
 def find_data_files():
     """
     Find IPython's data_files.
 
     Most of these are docs.
     """
 
     docdirbase  = pjoin('share', 'doc', 'ipython')
     manpagebase = pjoin('share', 'man', 'man1')
 
     # Simple file lists can be made by hand
     manpages = [f for f in glob(pjoin('docs','man','*.1.gz')) if isfile(f)]
     if not manpages:
         # When running from a source tree, the manpages aren't gzipped
         manpages = [f for f in glob(pjoin('docs','man','*.1')) if isfile(f)]
 
     igridhelpfiles = [f for f in glob(pjoin('IPython','extensions','igrid_help.*')) if isfile(f)]
 
     # For nested structures, use the utility above
     example_files = make_dir_struct(
         'data',
         pjoin('docs','examples'),
         pjoin(docdirbase,'examples')
     )
     manual_files = make_dir_struct(
         'data',
         pjoin('docs','html'),
         pjoin(docdirbase,'manual')
     )
 
     # And assemble the entire output list
     data_files = [ (manpagebase, manpages),
                    (pjoin(docdirbase, 'extensions'), igridhelpfiles),
                    ] + manual_files + example_files
 
     return data_files
 
 
 def make_man_update_target(manpage):
     """Return a target_update-compliant tuple for the given manpage.
 
     Parameters
     ----------
     manpage : string
       Name of the manpage, must include the section number (trailing number).
 
     Example
     -------
 
     >>> make_man_update_target('ipython.1') #doctest: +NORMALIZE_WHITESPACE
     ('docs/man/ipython.1.gz',
      ['docs/man/ipython.1'],
      'cd docs/man && gzip -9c ipython.1 > ipython.1.gz')
     """
     man_dir = pjoin('docs', 'man')
     manpage_gz = manpage + '.gz'
     manpath = pjoin(man_dir, manpage)
     manpath_gz = pjoin(man_dir, manpage_gz)
     gz_cmd = ( "cd %(man_dir)s && gzip -9c %(manpage)s > %(manpage_gz)s" %
                locals() )
     return (manpath_gz, [manpath], gz_cmd)
 
 # The two functions below are copied from IPython.utils.path, so we don't need
 # to import IPython during setup, which fails on Python 3.
 
 def target_outdated(target,deps):
     """Determine whether a target is out of date.
 
     target_outdated(target,deps) -> 1/0
 
     deps: list of filenames which MUST exist.
     target: single filename which may or may not exist.
 
     If target doesn't exist or is older than any file listed in deps, return
     true, otherwise return false.
     """
     try:
         target_time = os.path.getmtime(target)
     except os.error:
         return 1
     for dep in deps:
         dep_time = os.path.getmtime(dep)
         if dep_time > target_time:
             #print "For target",target,"Dep failed:",dep # dbg
             #print "times (dep,tar):",dep_time,target_time # dbg
             return 1
     return 0
 
 
 def target_update(target,deps,cmd):
     """Update a target with a given command given a list of dependencies.
 
     target_update(target,deps,cmd) -> runs cmd if target is outdated.
 
     This is just a wrapper around target_outdated() which calls the given
     command if target is outdated."""
 
     if target_outdated(target,deps):
         os.system(cmd)
 
 #---------------------------------------------------------------------------
 # Find scripts
 #---------------------------------------------------------------------------
 
 def find_scripts(entry_points=False, suffix=''):
     """Find IPython's scripts.
 
     if entry_points is True:
         return setuptools entry_point-style definitions
     else:
         return file paths of plain scripts [default]
 
     suffix is appended to script names if entry_points is True, so that the
     Python 3 scripts get named "ipython3" etc.
     """
     if entry_points:
         console_scripts = [s % suffix for s in [
-            'ipython%s = IPython.frontend.terminal.ipapp:launch_new_instance',
+            'ipython%s = IPython.terminal.ipapp:launch_new_instance',
             'pycolor%s = IPython.utils.PyColorize:main',
             'ipcontroller%s = IPython.parallel.apps.ipcontrollerapp:launch_new_instance',
             'ipengine%s = IPython.parallel.apps.ipengineapp:launch_new_instance',
             'iplogger%s = IPython.parallel.apps.iploggerapp:launch_new_instance',
             'ipcluster%s = IPython.parallel.apps.ipclusterapp:launch_new_instance',
             'iptest%s = IPython.testing.iptest:main',
             'irunner%s = IPython.lib.irunner:main'
         ]]
         gui_scripts = []
         scripts = dict(console_scripts=console_scripts, gui_scripts=gui_scripts)
     else:
         parallel_scripts = pjoin('IPython','parallel','scripts')
         main_scripts = pjoin('IPython','scripts')
         scripts = [
                    pjoin(parallel_scripts, 'ipengine'),
                    pjoin(parallel_scripts, 'ipcontroller'),
                    pjoin(parallel_scripts, 'ipcluster'),
                    pjoin(parallel_scripts, 'iplogger'),
                    pjoin(main_scripts, 'ipython'),
                    pjoin(main_scripts, 'pycolor'),
                    pjoin(main_scripts, 'irunner'),
                    pjoin(main_scripts, 'iptest')
         ]
     return scripts
 
 #---------------------------------------------------------------------------
 # Verify all dependencies
 #---------------------------------------------------------------------------
 
 def check_for_dependencies():
     """Check for IPython's dependencies.
 
     This function should NOT be called if running under setuptools!
     """
     from setupext.setupext import (
         print_line, print_raw, print_status,
         check_for_sphinx, check_for_pygments,
         check_for_nose, check_for_pexpect,
         check_for_pyzmq, check_for_readline
     )
     print_line()
     print_raw("BUILDING IPYTHON")
     print_status('python', sys.version)
     print_status('platform', sys.platform)
     if sys.platform == 'win32':
         print_status('Windows version', sys.getwindowsversion())
 
     print_raw("")
     print_raw("OPTIONAL DEPENDENCIES")
 
     check_for_sphinx()
     check_for_pygments()
     check_for_nose()
     check_for_pexpect()
     check_for_pyzmq()
     check_for_readline()
 
 #---------------------------------------------------------------------------
 # VCS related
 #---------------------------------------------------------------------------
 
 # utils.submodule has checks for submodule status
 execfile(pjoin('IPython','utils','submodule.py'), globals())
 
 class UpdateSubmodules(Command):
     """Update git submodules
     
     IPython's external javascript dependencies live in a separate repo.
     """
     description = "Update git submodules"
     user_options = []
     
     def initialize_options(self):
         pass
     
     def finalize_options(self):
         pass
     
     def run(self):
         failure = False
         try:
             self.spawn('git submodule init'.split())
             self.spawn('git submodule update --recursive'.split())
         except Exception as e:
             failure = e
             print(e)
         
         if not check_submodule_status(repo_root) == 'clean':
             print("submodules could not be checked out")
             sys.exit(1)
 
 
 def git_prebuild(pkg_dir, build_cmd=build_py):
     """Return extended build or sdist command class for recording commit
     
     records git commit in IPython.utils._sysinfo.commit
     
     for use in IPython.utils.sysinfo.sys_info() calls after installation.
     
     Also ensures that submodules exist prior to running
     """
     
     class MyBuildPy(build_cmd):
         ''' Subclass to write commit data into installation tree '''
         def run(self):
             build_cmd.run(self)
             # this one will only fire for build commands
             if hasattr(self, 'build_lib'):
                 self._record_commit(self.build_lib)
         
         def make_release_tree(self, base_dir, files):
             # this one will fire for sdist
             build_cmd.make_release_tree(self, base_dir, files)
             self._record_commit(base_dir)
         
         def _record_commit(self, base_dir):
             import subprocess
             proc = subprocess.Popen('git rev-parse --short HEAD',
                                     stdout=subprocess.PIPE,
                                     stderr=subprocess.PIPE,
                                     shell=True)
             repo_commit, _ = proc.communicate()
             repo_commit = repo_commit.strip().decode("ascii")
             
             out_pth = pjoin(base_dir, pkg_dir, 'utils', '_sysinfo.py')
             if os.path.isfile(out_pth) and not repo_commit:
                 # nothing to write, don't clobber
                 return
             
             print("writing git commit '%s' to %s" % (repo_commit, out_pth))
             
             # remove to avoid overwriting original via hard link
             try:
                 os.remove(out_pth)
             except (IOError, OSError):
                 pass
             with open(out_pth, 'w') as out_file:
                 out_file.writelines([
                     '# GENERATED BY setup.py\n',
                     'commit = "%s"\n' % repo_commit,
                 ])
     return require_submodules(MyBuildPy)
 
 
 def require_submodules(command):
     """decorator for instructing a command to check for submodules before running"""
     class DecoratedCommand(command):
         def run(self):
             if not check_submodule_status(repo_root) == 'clean':
                 print("submodules missing! Run `setup.py submodule` and try again")
                 sys.exit(1)
             command.run(self)
     return DecoratedCommand

IPython/deathrow/Gnuplot2.py

@@ -1,665 +0,0 b''
-# -*- coding: utf-8 -*-
-"""Improved replacement for the Gnuplot.Gnuplot class.
-
-This module imports Gnuplot and replaces some of its functionality with
-improved versions. They add better handling of arrays for plotting and more
-convenient PostScript generation, plus some fixes for hardcopy().
-
-It also adds a convenient plot2 method for plotting dictionaries and
-lists/tuples of arrays.
-
-This module is meant to be used as a drop-in replacement to the original
-Gnuplot, so it should be safe to do:
-
-import IPython.Gnuplot2 as Gnuplot
-"""
-
-import cStringIO
-import os
-import string
-import sys
-import tempfile
-import time
-import types
-
-import Gnuplot as Gnuplot_ori
-import Numeric
-
-from IPython.utils.genutils import popkey,xsys
-
-# needed by hardcopy():
-gp = Gnuplot_ori.gp
-
-# Patch for Gnuplot.py 1.6 compatibility.
-# Thanks to Hayden Callow <[e-mail]>
-try:
-    OptionException = Gnuplot_ori.PlotItems.OptionException
-except AttributeError:
-    OptionException = Gnuplot_ori.Errors.OptionError
-
-# exhibit a similar interface to Gnuplot so it can be somewhat drop-in
-Data      = Gnuplot_ori.Data
-Func      = Gnuplot_ori.Func
-GridData  = Gnuplot_ori.GridData
-PlotItem  = Gnuplot_ori.PlotItem
-PlotItems = Gnuplot_ori.PlotItems
-
-# Modify some of Gnuplot's functions with improved versions (or bugfixed, in
-# hardcopy's case). In order to preserve the docstrings at runtime, I've
-# copied them from the original code.
-
-# After some significant changes in v 1.7 of Gnuplot.py, we need to do a bit
-# of version checking.
-
-if Gnuplot_ori.__version__ <= '1.6':
-    _BaseFileItem = PlotItems.File
-    _BaseTempFileItem = PlotItems.TempFile
-
-    # Fix the File class to add the 'index' option for Gnuplot versions < 1.7
-    class File(_BaseFileItem):
-
-        _option_list = _BaseFileItem._option_list.copy()
-        _option_list.update({
-            'index' : lambda self, index: self.set_option_index(index),
-            })
-
-        # A new initializer is needed b/c we want to add a modified
-        # _option_sequence list which includes 'index' in the right place.
-        def __init__(self,*args,**kw):
-            self._option_sequence = ['binary', 'index', 'using', 'smooth', 'axes',
-                         'title', 'with']
-
-            _BaseFileItem.__init__(self,*args,**kw)
-
-        # Let's fix the constructor docstring
-        __newdoc = \
-            """Additional Keyword arguments added by IPython:
-
-             'index=<int>' -- similar to the `index` keyword in Gnuplot.
-                 This allows only some of the datasets in a file to be
-                 plotted. Datasets within a file are assumed to be separated
-                 by _pairs_ of blank lines, and the first one is numbered as
-                 0 (similar to C/Python usage)."""
-        __init__.__doc__ = PlotItems.File.__init__.__doc__ + __newdoc
-
-        def set_option_index(self, index):
-            if index is None:
-                self.clear_option('index')
-            elif type(index) in [type(''), type(1)]:
-                self._options['index'] = (index, 'index %s' % index)
-            elif type(index) is type(()):
-                self._options['index'] = (index,'index %s' %
-                                          string.join(map(repr, index), ':'))
-            else:
-                raise OptionException('index=%s' % (index,))
-
-    # We need a FileClass with a different name from 'File', which is a
-    # factory function in 1.7, so that our String class can subclass FileClass
-    # in any version.
-    _FileClass = File
-
-elif Gnuplot_ori.__version__ =='1.7':
-    _FileClass = _BaseFileItem = PlotItems._FileItem
-    _BaseTempFileItem = PlotItems._TempFileItem
-    File = PlotItems.File
-
-else:  # changes in the newer version (svn as of March'06)
-     _FileClass = _BaseFileItem = PlotItems._FileItem
-     _BaseTempFileItem = PlotItems._NewFileItem
-     File = PlotItems.File
-
-
-# Now, we can add our generic code which is version independent
-
-# First some useful utilities
-def eps_fix_bbox(fname):
-    """Fix the bounding box of an eps file by running ps2eps on it.
-
-    If its name ends in .eps, the original file is removed.
-
-    This is particularly useful for plots made by Gnuplot with square aspect
-    ratio: there is a bug in Gnuplot which makes it generate a bounding box
-    which is far wider than the actual plot.
-
-    This function assumes that ps2eps is installed in your system."""
-
-    # note: ps2ps and eps2eps do NOT work, ONLY ps2eps works correctly. The
-    # others make output with bitmapped fonts, which looks horrible.
-    print 'Fixing eps file: <%s>' % fname
-    xsys('ps2eps -f -q -l %s' % fname)
-    if fname.endswith('.eps'):
-        os.rename(fname+'.eps',fname)
-
-def is_list1d(x,containers = [types.ListType,types.TupleType]):
-    """Returns true if x appears to be a 1d list/tuple/array.
-
-    The heuristics are: identify Numeric arrays, or lists/tuples whose first
-    element is not itself a list/tuple. This way zipped lists should work like
-    the original Gnuplot. There's no inexpensive way to know if a list doesn't
-    have a composite object after its first element, so that kind of input
-    will produce an error. But it should work well in most cases.
-    """
-    x_type = type(x)
-
-    return x_type == Numeric.ArrayType and len(x.shape)==1 or \
-           (x_type in containers and
-            type(x[0]) not in containers + [Numeric.ArrayType])
-
-def zip_items(items,titles=None):
-    """zip together neighboring 1-d arrays, and zip standalone ones
-    with their index. Leave other plot items alone."""
-
-    class StandaloneItem(Exception): pass
-
-    def get_titles(titles):
-        """Return the next title and the input titles array.
-
-        The input array may be changed to None when no titles are left to
-        prevent extra unnecessary calls to this function."""
-
-        try:
-            title = titles[tit_ct[0]]  # tit_ct[0] is in zip_items'scope
-        except IndexError:
-            titles = None # so we don't enter again
-            title = None
-        else:
-            tit_ct[0] += 1
-        return title,titles
-
-    new_items = []
-
-    if titles:
-        # Initialize counter. It was put in a list as a hack to allow the
-        # nested get_titles to modify it without raising a NameError.
-        tit_ct = [0]
-
-    n = 0  # this loop needs to be done by hand
-    while n < len(items):
-        item = items[n]
-        try:
-            if is_list1d(item):
-                if n==len(items)-1: # last in list
-                    raise StandaloneItem
-                else: # check the next item and zip together if needed
-                    next_item = items[n+1]
-                    if next_item is None:
-                        n += 1
-                        raise StandaloneItem
-                    elif is_list1d(next_item):
-                        # this would be best done with an iterator
-                        if titles:
-                            title,titles = get_titles(titles)
-                        else:
-                            title = None
-                        new_items.append(Data(zip(item,next_item),
-                                              title=title))
-                        n += 1  # avoid double-inclusion of next item
-                    else: # can't zip with next, zip with own index list
-                        raise StandaloneItem
-            else:  # not 1-d array
-                new_items.append(item)
-        except StandaloneItem:
-            if titles:
-                title,titles = get_titles(titles)
-            else:
-                title = None
-            new_items.append(Data(zip(range(len(item)),item),title=title))
-        except AttributeError:
-            new_items.append(item)
-        n+=1
-
-    return new_items
-
-# And some classes with enhanced functionality.
-class String(_FileClass):
-    """Make a PlotItem from data in a string with the same format as a File.
-
-    This allows writing data directly inside python scripts using the exact
-    same format and manipulation options which would be used for external
-    files."""
-
-    def __init__(self, data_str, **keyw):
-        """Construct a String object.
-
-        <data_str> is a string formatted exactly like a valid Gnuplot data
-        file would be. All options from the File constructor are valid here.
-
-        Warning: when used for interactive plotting in scripts which exit
-        immediately, you may get an error because the temporary file used to
-        hold the string data was deleted before Gnuplot had a chance to see
-        it. You can work around this problem by putting a raw_input() call at
-        the end of the script.
-
-        This problem does not appear when generating PostScript output, only
-        with Gnuplot windows."""
-
-        self.tmpfile = _BaseTempFileItem()
-        tmpfile = file(self.tmpfile.filename,'w')
-        tmpfile.write(data_str)
-        _BaseFileItem.__init__(self,self.tmpfile,**keyw)
-
-
-class Gnuplot(Gnuplot_ori.Gnuplot):
-    """Improved Gnuplot class.
-
-    Enhancements: better plot,replot and hardcopy methods. New methods for
-    quick range setting.
-    """
-
-    def xrange(self,min='*',max='*'):
-        """Set xrange. If min/max is omitted, it is set to '*' (auto).
-
-        Note that this is different from the regular Gnuplot behavior, where
-        an unspecified limit means no change. Here any unspecified limit is
-        set to autoscaling, allowing these functions to be used for full
-        autoscaling when called with no arguments.
-
-        To preserve one limit's current value while changing the other, an
-        explicit '' argument must be given as the limit to be kept.
-
-        Similar functions exist for [y{2}z{2}rtuv]range."""
-
-        self('set xrange [%s:%s]' % (min,max))
-
-    def yrange(self,min='*',max='*'):
-        self('set yrange [%s:%s]' % (min,max))
-
-    def zrange(self,min='*',max='*'):
-        self('set zrange [%s:%s]' % (min,max))
-
-    def x2range(self,min='*',max='*'):
-        self('set xrange [%s:%s]' % (min,max))
-
-    def y2range(self,min='*',max='*'):
-        self('set yrange [%s:%s]' % (min,max))
-
-    def z2range(self,min='*',max='*'):
-        self('set zrange [%s:%s]' % (min,max))
-
-    def rrange(self,min='*',max='*'):
-        self('set rrange [%s:%s]' % (min,max))
-
-    def trange(self,min='*',max='*'):
-        self('set trange [%s:%s]' % (min,max))
-
-    def urange(self,min='*',max='*'):
-        self('set urange [%s:%s]' % (min,max))
-
-    def vrange(self,min='*',max='*'):
-        self('set vrange [%s:%s]' % (min,max))
-
-    def set_ps(self,option):
-        """Set an option for the PostScript terminal and reset default term."""
-
-        self('set terminal postscript %s ' % option)
-        self('set terminal %s' % gp.GnuplotOpts.default_term)
-
-    def __plot_ps(self, plot_method,*items, **keyw):
-        """Wrapper for plot/splot/replot, with processing of hardcopy options.
-
-        For internal use only."""
-
-        # Filter out PostScript options which will crash the normal plot/replot
-        psargs = {'filename':None,
-                  'mode':None,
-                  'eps':None,
-                  'enhanced':None,
-                  'color':None,
-                  'solid':None,
-                  'duplexing':None,
-                  'fontname':None,
-                  'fontsize':None,
-                  'debug':0 }
-
-        for k in psargs.keys():
-            if keyw.has_key(k):
-                psargs[k] = keyw[k]
-                del keyw[k]
-
-        # Filter out other options the original plot doesn't know
-        hardcopy = popkey(keyw,'hardcopy',psargs['filename'] is not None)
-        titles = popkey(keyw,'titles',0)
-
-        # the filename keyword should control hardcopy generation, this is an
-        # override switch only which needs to be explicitly set to zero
-        if hardcopy:
-            if psargs['filename'] is None:
-                raise ValueError, \
-                      'If you request hardcopy, you must give a filename.'
-
-            # set null output so nothing goes to screen. hardcopy() restores output
-            self('set term dumb')
-            # I don't know how to prevent screen output in Windows
-            if os.name == 'posix':
-                self('set output "/dev/null"')
-
-        new_items = zip_items(items,titles)
-        # plot_method is either plot or replot from the original Gnuplot class:
-        plot_method(self,*new_items,**keyw)
-
-        # Do hardcopy if requested
-        if hardcopy:
-            if psargs['filename'].endswith('.eps'):
-                psargs['eps'] = 1
-            self.hardcopy(**psargs)
-
-    def plot(self, *items, **keyw):
-        """Draw a new plot.
-
-        Clear the current plot and create a new 2-d plot containing
-        the specified items.  Each arguments should be of the
-        following types:
-
-        'PlotItem' (e.g., 'Data', 'File', 'Func') -- This is the most
-            flexible way to call plot because the PlotItems can
-            contain suboptions.  Moreover, PlotItems can be saved to
-            variables so that their lifetime is longer than one plot
-            command; thus they can be replotted with minimal overhead.
-
-        'string' (e.g., 'sin(x)') -- The string is interpreted as
-            'Func(string)' (a function that is computed by gnuplot).
-
-        Anything else -- The object, which should be convertible to an
-            array, is passed to the 'Data' constructor, and thus
-            plotted as data.  If the conversion fails, an exception is
-            raised.
-
-
-        This is a modified version of plot(). Compared to the original in
-        Gnuplot.py, this version has several enhancements, listed below.
-
-
-        Modifications to the input arguments
-        ------------------------------------
-
-        (1-d array means Numeric array, list or tuple):
-
-        (i) Any 1-d array which is NOT followed by another 1-d array, is
-        automatically zipped with range(len(array_1d)). Typing g.plot(y) will
-        plot y against its indices.
-
-        (ii) If two 1-d arrays are contiguous in the argument list, they are
-        automatically zipped together. So g.plot(x,y) plots y vs. x, and
-        g.plot(x1,y1,x2,y2) plots y1 vs. x1 and y2 vs. x2.
-
-        (iii) Any 1-d array which is followed by None is automatically zipped
-        with range(len(array_1d)). In this form, typing g.plot(y1,None,y2)
-        will plot both y1 and y2 against their respective indices (and NOT
-        versus one another). The None prevents zipping y1 and y2 together, and
-        since y2 is unpaired it is automatically zipped to its indices by (i)
-
-        (iv) Any other arguments which don't match these cases are left alone and
-        passed to the code below.
-
-        For lists or tuples, the heuristics used to determine whether they are
-        in fact 1-d is fairly simplistic: their first element is checked, and
-        if it is not a list or tuple itself, it is assumed that the whole
-        object is one-dimensional.
-
-        An additional optional keyword 'titles' has been added: it must be a
-        list of strings to be used as labels for the individual plots which
-        are NOT PlotItem objects (since those objects carry their own labels
-        within).
-
-
-        PostScript generation
-        ---------------------
-
-        This version of plot() also handles automatically the production of
-        PostScript output. The main options are (given as keyword arguments):
-
-        - filename: a string, typically ending in .eps. If given, the plot is
-        sent to this file in PostScript format.
-
-        - hardcopy: this can be set to 0 to override 'filename'. It does not
-        need to be given to produce PostScript, its purpose is to allow
-        switching PostScript output off globally in scripts without having to
-        manually change 'filename' values in multiple calls.
-
-        All other keywords accepted by Gnuplot.hardcopy() are transparently
-        passed, and safely ignored if output is sent to the screen instead of
-        PostScript.
-
-        For example:
-
-        In [1]: x=frange(0,2*pi,npts=100)
-
-        Generate a plot in file 'sin.eps':
-
-        In [2]: plot(x,sin(x),filename = 'sin.eps')
-
-        Plot to screen instead, without having to change the filename:
-
-        In [3]: plot(x,sin(x),filename = 'sin.eps',hardcopy=0)
-
-        Pass the 'color=0' option to hardcopy for monochrome output:
-
-        In [4]: plot(x,sin(x),filename = 'sin.eps',color=0)
-
-        PostScript generation through plot() is useful mainly for scripting
-        uses where you are not interested in interactive plotting. For
-        interactive use, the hardcopy() function is typically more convenient:
-
-        In [5]: plot(x,sin(x))
-
-        In [6]: hardcopy('sin.eps')  """
-
-        self.__plot_ps(Gnuplot_ori.Gnuplot.plot,*items,**keyw)
-
-    def plot2(self,arg,**kw):
-        """Plot the entries of a dictionary or a list/tuple of arrays.
-
-        This simple utility calls plot() with a list of Gnuplot.Data objects
-        constructed either from the values of the input dictionary, or the entries
-        in it if it is a tuple or list.  Each item gets labeled with the key/index
-        in the Gnuplot legend.
-
-        Each item is plotted by zipping it with a list of its indices.
-
-        Any keywords are passed directly to plot()."""
-
-        if hasattr(arg,'keys'):
-            keys = arg.keys()
-            keys.sort()
-        else:
-            keys = range(len(arg))
-
-        pitems = [Data(zip(range(len(arg[k])),arg[k]),title=`k`) for k in keys]
-        self.plot(*pitems,**kw)
-
-    def splot(self, *items, **keyw):
-        """Draw a new three-dimensional plot.
-
-        Clear the current plot and create a new 3-d plot containing
-        the specified items.  Arguments can be of the following types:
-
-        'PlotItem' (e.g., 'Data', 'File', 'Func', 'GridData' ) -- This
-            is the most flexible way to call plot because the
-            PlotItems can contain suboptions.  Moreover, PlotItems can
-            be saved to variables so that their lifetime is longer
-            than one plot command--thus they can be replotted with
-            minimal overhead.
-
-        'string' (e.g., 'sin(x*y)') -- The string is interpreted as a
-            'Func()' (a function that is computed by gnuplot).
-
-        Anything else -- The object is converted to a Data() item, and
-            thus plotted as data.  Note that each data point should
-            normally have at least three values associated with it
-            (i.e., x, y, and z).  If the conversion fails, an
-            exception is raised.
-
-        This is a modified version of splot(). Compared to the original in
-        Gnuplot.py, this version has several enhancements, listed in the
-        plot() documentation.
-        """
-
-        self.__plot_ps(Gnuplot_ori.Gnuplot.splot,*items,**keyw)
-
-    def replot(self, *items, **keyw):
-        """Replot the data, possibly adding new 'PlotItem's.
-
-        Replot the existing graph, using the items in the current
-        itemlist.  If arguments are specified, they are interpreted as
-        additional items to be plotted alongside the existing items on
-        the same graph.  See 'plot' for details.
-
-        If you want to replot to a postscript file, you MUST give the
-        'filename' keyword argument in each call to replot. The Gnuplot python
-        interface has no way of knowing that your previous call to
-        Gnuplot.plot() was meant for PostScript output."""
-
-        self.__plot_ps(Gnuplot_ori.Gnuplot.replot,*items,**keyw)
-
-    # The original hardcopy has a bug. See fix at the end. The rest of the code
-    # was lifted verbatim from the original, so that people using IPython get the
-    # benefits without having to manually patch Gnuplot.py
-    def hardcopy(self, filename=None,
-                 mode=None,
-                 eps=None,
-                 enhanced=None,
-                 color=None,
-                 solid=None,
-                 duplexing=None,
-                 fontname=None,
-                 fontsize=None,
-                 debug = 0,
-                 ):
-        """Create a hardcopy of the current plot.
-
-        Create a postscript hardcopy of the current plot to the
-        default printer (if configured) or to the specified filename.
-
-        Note that gnuplot remembers the postscript suboptions across
-        terminal changes.  Therefore if you set, for example, color=1
-        for one hardcopy then the next hardcopy will also be color
-        unless you explicitly choose color=0.  Alternately you can
-        force all of the options to their defaults by setting
-        mode='default'.  I consider this to be a bug in gnuplot.
-
-        Keyword arguments:
-
-          'filename=<string>' -- if a filename is specified, save the
-              output in that file; otherwise print it immediately
-              using the 'default_lpr' configuration option.  If the
-              filename ends in '.eps', EPS mode is automatically
-              selected (like manually specifying eps=1 or mode='eps').
-
-          'mode=<string>' -- set the postscript submode ('landscape',
-              'portrait', 'eps', or 'default').  The default is
-              to leave this option unspecified.
-
-          'eps=<bool>' -- shorthand for 'mode="eps"'; asks gnuplot to
-              generate encapsulated postscript.
-
-          'enhanced=<bool>' -- if set (the default), then generate
-              enhanced postscript, which allows extra features like
-              font-switching, superscripts, and subscripts in axis
-              labels.  (Some old gnuplot versions do not support
-              enhanced postscript; if this is the case set
-              gp.GnuplotOpts.prefer_enhanced_postscript=None.)
-
-          'color=<bool>' -- if set, create a plot with color.  Default
-              is to leave this option unchanged.
-
-          'solid=<bool>' -- if set, force lines to be solid (i.e., not
-              dashed).
-
-          'duplexing=<string>' -- set duplexing option ('defaultplex',
-              'simplex', or 'duplex').  Only request double-sided
-              printing if your printer can handle it.  Actually this
-              option is probably meaningless since hardcopy() can only
-              print a single plot at a time.
-
-          'fontname=<string>' -- set the default font to <string>,
-              which must be a valid postscript font.  The default is
-              to leave this option unspecified.
-
-          'fontsize=<double>' -- set the default font size, in
-              postscript points.
-
-          'debug=<bool>' -- print extra debugging information (useful if
-              your PostScript files are misteriously not being created).
-        """
-
-        if filename is None:
-            assert gp.GnuplotOpts.default_lpr is not None, \
-                   OptionException('default_lpr is not set, so you can only '
-                                   'print to a file.')
-            filename = gp.GnuplotOpts.default_lpr
-            lpr_output = 1
-        else:
-            if filename.endswith('.eps'):
-                eps = 1
-            lpr_output = 0
-
-        # Be careful processing the options.  If the user didn't
-        # request an option explicitly, do not specify it on the 'set
-        # terminal' line (don't even specify the default value for the
-        # option).  This is to avoid confusing older versions of
-        # gnuplot that do not support all of these options.  The
-        # exception is 'enhanced', which is just too useful to have to
-        # specify each time!
-
-        setterm = ['set', 'terminal', 'postscript']
-        if eps:
-            assert mode is None or mode=='eps', \
-                   OptionException('eps option and mode are incompatible')
-            setterm.append('eps')
-        else:
-            if mode is not None:
-                assert mode in ['landscape', 'portrait', 'eps', 'default'], \
-                       OptionException('illegal mode "%s"' % mode)
-                setterm.append(mode)
-        if enhanced is None:
-            enhanced = gp.GnuplotOpts.prefer_enhanced_postscript
-        if enhanced is not None:
-            if enhanced: setterm.append('enhanced')
-            else: setterm.append('noenhanced')
-        if color is not None:
-            if color: setterm.append('color')
-            else: setterm.append('monochrome')
-        if solid is not None:
-            if solid: setterm.append('solid')
-            else: setterm.append('dashed')
-        if duplexing is not None:
-            assert duplexing in ['defaultplex', 'simplex', 'duplex'], \
-                   OptionException('illegal duplexing mode "%s"' % duplexing)
-            setterm.append(duplexing)
-        if fontname is not None:
-            setterm.append('"%s"' % fontname)
-        if fontsize is not None:
-            setterm.append('%s' % fontsize)
-
-        self(string.join(setterm))
-        self.set_string('output', filename)
-        # replot the current figure (to the printer):
-        self.refresh()
-
-        # fperez. Ugly kludge: often for some reason the file is NOT created
-        # and we must reissue the creation commands. I have no idea why!
-        if not lpr_output:
-            #print 'Hardcopy <%s>' % filename  # dbg
-            maxtries = 20
-            delay = 0.1  # delay (in seconds) between print attempts
-            for i in range(maxtries):
-                time.sleep(0.05)  # safety, very small delay
-                if os.path.isfile(filename):
-                    if debug:
-                        print 'Hardcopy to file <%s> success at attempt #%s.' \
-                        % (filename,i+1)
-                    break
-                time.sleep(delay)
-                # try again, issue all commands just in case
-                self(string.join(setterm))
-                self.set_string('output', filename)
-                self.refresh()
-            if not os.path.isfile(filename):
-                print >> sys.stderr,'ERROR: Tried %s times and failed to '\
-                'create hardcopy file `%s`' % (maxtries,filename)
-
-        # reset the terminal to its `default' setting:
-        self('set terminal %s' % gp.GnuplotOpts.default_term)
-        self.set_string('output')
-
-#********************** End of file <Gnuplot2.py> ************************

IPython/deathrow/GnuplotInteractive.py

@@ -1,148 +0,0 b''
-# -*- coding: utf-8 -*-
-"""Interactive functions and magic functions for Gnuplot usage.
-
-This requires the Gnuplot.py module for interfacing python with Gnuplot, which
-can be downloaded from:
-
-http://gnuplot-py.sourceforge.net/
-
-See gphelp() below for details on the services offered by this module.
-
-Inspired by a suggestion/request from Arnd Baecker.
-"""
-
-__all__ = ['Gnuplot','gp','gp_new','plot','plot2','splot','replot',
-           'hardcopy','gpdata','gpfile','gpstring','gpfunc','gpgrid',
-           'gphelp']
-
-import IPython.GnuplotRuntime as GRun
-from IPython.utils.genutils import warn
-from IPython.core import page
-
-# Set global names for interactive use
-Gnuplot  = GRun.Gnuplot
-gp_new   = GRun.gp_new
-gp       = GRun.gp
-plot     = gp.plot
-plot2    = gp.plot2
-splot    = gp.splot
-replot   = gp.replot
-hardcopy = gp.hardcopy
-
-# Accessors for the main plot object constructors:
-gpdata   = Gnuplot.Data
-gpfile   = Gnuplot.File
-gpstring = Gnuplot.String
-gpfunc   = Gnuplot.Func
-gpgrid   = Gnuplot.GridData
-
-def gphelp():
-    """Print information about the Gnuplot facilities in IPython."""
-
-    page("""
-IPython provides an interface to access the Gnuplot scientific plotting
-system, in an environment similar to that of Mathematica or Matlab.
-
-New top-level global objects
-----------------------------
-
-Please see their respective docstrings for further details.
-
-- gp: a running Gnuplot instance. You can access its methods as
-gp.<method>. gp(`a string`) will execute the given string as if it had been
-typed in an interactive gnuplot window.
-
-- plot, splot, replot and hardcopy: aliases to the methods of the same name in
-the global running Gnuplot instance gp. These allow you to simply type:
-
-In [1]: plot(x,sin(x),title='Sin(x)')  # assuming x is a Numeric array
-
-and obtain a plot of sin(x) vs x with the title 'Sin(x)'.
-
-- gp_new: a function which returns a new Gnuplot instance. This can be used to
-have multiple Gnuplot instances running in your session to compare different
-plots, each in a separate window.
-
-- Gnuplot: alias to the Gnuplot2 module, an improved drop-in replacement for
-the original Gnuplot.py. Gnuplot2 needs Gnuplot but redefines several of its
-functions with improved versions (Gnuplot2 comes with IPython).
-
-- gpdata, gpfile, gpstring, gpfunc, gpgrid: aliases to Gnuplot.Data,
-Gnuplot.File, Gnuplot.String, Gnuplot.Func and Gnuplot.GridData
-respectively. These functions create objects which can then be passed to the
-plotting commands. See the Gnuplot.py documentation for details.
-
-Keep in mind that all commands passed to a Gnuplot instance are executed in
-the Gnuplot namespace, where no Python variables exist. For example, for
-plotting sin(x) vs x as above, typing
-
-In [2]: gp('plot x,sin(x)')
-
-would not work. Instead, you would get the plot of BOTH the functions 'x' and
-'sin(x)', since Gnuplot doesn't know about the 'x' Python array. The plot()
-method lives in python and does know about these variables.
-
-
-New magic functions
--------------------
-
-%gpc: pass one command to Gnuplot and execute it or open a Gnuplot shell where
-each line of input is executed.
-
-%gp_set_default: reset the value of IPython's global Gnuplot instance.""")
-    
-# Code below is all for IPython use
-# Define the magic functions for communicating with the above gnuplot instance.
-def magic_gpc(self,parameter_s=''):
-    """Execute a gnuplot command or open a gnuplot shell.
-
-    Usage (omit the % if automagic is on). There are two ways to use it:
-
-      1) %gpc 'command' -> passes 'command' directly to the gnuplot instance.
-
-      2) %gpc -> will open up a prompt (gnuplot>>>) which takes input like the
-      standard gnuplot interactive prompt. If you need to type a multi-line
-      command, use \\ at the end of each intermediate line.
-
-      Upon exiting of the gnuplot sub-shell, you return to your IPython
-      session (the gnuplot sub-shell can be invoked as many times as needed).
-      """
-
-    if parameter_s.strip():
-        self.shell.gnuplot(parameter_s)
-    else:
-        self.shell.gnuplot.interact()
-
-def magic_gp_set_default(self,parameter_s=''):
-    """Set the default gnuplot instance accessed by the %gp magic function.
-
-    %gp_set_default name
-
-    Call with the name of the new instance at the command line. If you want to
-    set this instance in your own code (using an embedded IPython, for
-    example), simply set the variable __IPYTHON__.gnuplot to your own gnuplot
-    instance object."""
-
-    gname = parameter_s.strip()
-    G = eval(gname,self.shell.user_ns)
-    self.shell.gnuplot = G
-    self.shell.user_ns.update({'plot':G.plot,'splot':G.splot,'plot2':G.plot2,
-                               'replot':G.replot,'hardcopy':G.hardcopy})
-
-try:
-    __IPYTHON__
-except NameError:
-    pass
-else:
-    # make the global Gnuplot instance known to IPython
-    __IPYTHON__.gnuplot = GRun.gp
-    __IPYTHON__.gnuplot.shell_first_time = 1
-
-    print """*** Type `gphelp` for help on the Gnuplot integration features."""
-
-    # Add the new magic functions to the class dict
-    from IPython.core.iplib import InteractiveShell
-    InteractiveShell.magic_gpc = magic_gpc
-    InteractiveShell.magic_gp_set_default = magic_gp_set_default
-
-#********************** End of file <GnuplotInteractive.py> *******************

IPython/deathrow/GnuplotRuntime.py

@@ -1,146 +0,0 b''
-# -*- coding: utf-8 -*-
-"""Basic Gnuplot functionality for inclusion in other code.
-
-This module creates a running Gnuplot instance called 'gp' and builds other
-convenient globals for quick use in running scripts. It is intended to allow
-you to script plotting tasks in Python with a minimum of effort. A typical
-usage would be:
-
-import IPython.GnuplotRuntime as GP  # or some other short name
-GP.gp.plot(GP.File('your_data.dat'))
-
-
-This module exposes the following objects:
-
-- gp: a running Gnuplot instance. You can access its methods as
-gp.<method>. gp(`a string`) will execute the given string as if it had been
-typed in an interactive gnuplot window.
-
-- gp_new: a function which returns a new Gnuplot instance. This can be used to
-have multiple Gnuplot instances running in your session to compare different
-plots.
-
-- Gnuplot: alias to the Gnuplot2 module, an improved drop-in replacement for
-the original Gnuplot.py. Gnuplot2 needs Gnuplot but redefines several of its
-functions with improved versions (Gnuplot2 comes with IPython).
-
-- Data: alias to Gnuplot.Data, makes a PlotItem from array data.
-
-- File: alias to Gnuplot.File, makes a PlotItem from a file.
-
-- String: alias to Gnuplot.String, makes a PlotItem from a string formatted
-exactly like a file for Gnuplot.File would be.
-
-- Func: alias to Gnuplot.Func, makes a PlotItem from a function string.
-
-- GridData: alias to Gnuplot.GridData, makes a PlotItem from grid data.
-
-- pm3d_config: a string with Gnuplot commands to set up the pm3d mode for
-surface plotting. You can activate it simply by calling gp(pm3d_config).
-
-- eps_fix_bbox: A Unix-only function to fix eps files with bad bounding boxes
-(which Gnuplot generates when the plot size is set to square).
-
-This requires the Gnuplot.py module for interfacing Python with Gnuplot, which
-can be downloaded from:
-
-http://gnuplot-py.sourceforge.net/
-
-Inspired by a suggestion/request from Arnd Baecker.
-"""
-
-__all__ = ['Gnuplot','gp','gp_new','Data','File','Func','GridData',
-           'pm3d_config','eps_fix_bbox']
-
-import os,tempfile,sys
-from IPython.utils.process import getoutput
-
-#---------------------------------------------------------------------------
-# Notes on mouse support for Gnuplot.py
-
-# If you do not have a mouse-enabled gnuplot, set gnuplot_mouse to 0. If you
-# use gnuplot, you should really grab a recent, mouse enabled copy. It is an
-# extremely useful feature.  Mouse support is official as of gnuplot 4.0,
-# released in April 2004.
-
-# For the mouse features to work correctly, you MUST set your Gnuplot.py
-# module to use temporary files instead of 'inline data' for data
-# communication. Note that this is the default, so unless you've manually
-# fiddled with it you should be ok. If you need to make changes, in the
-# Gnuplot module directory, loook for the gp_unix.py file and make sure the
-# prefer_inline_data variable is set to 0. If you set it to 1 Gnuplot.py will
-# try to pass the data to gnuplot via standard input, which completely
-# confuses the mouse control system (even though it may be a bit faster than
-# using temp files).
-
-# As of Gnuplot.py v1.7, a new option was added to use FIFOs (pipes).  This
-# mechanism, while fast, also breaks the mouse system.  You must therefore set
-# the variable prefer_fifo_data to 0 in gp_unix.py.
-
-tmpname = tempfile.mktemp()
-open(tmpname,'w').write('set mouse')
-gnu_out = getoutput('gnuplot '+ tmpname)
-os.unlink(tmpname)
-if gnu_out:  # Gnuplot won't print anything if it has mouse support
-    print "*** Your version of Gnuplot appears not to have mouse support."
-    gnuplot_mouse = 0
-else:
-    gnuplot_mouse = 1
-del tmpname,gnu_out
-
-# Default state for persistence of new gnuplot instances
-if os.name in ['nt','dos'] or sys.platform == 'cygwin':
-    gnuplot_persist = 0
-else:
-    gnuplot_persist = 1
-
-import IPython.Gnuplot2 as Gnuplot
-
-class NotGiven: pass
-
-def gp_new(mouse=NotGiven,persist=NotGiven):
-    """Return a new Gnuplot instance.
-
-    The instance returned uses the improved methods defined in Gnuplot2.
-
-    Options (boolean):
-
-    - mouse: if unspecified, the module global gnuplot_mouse is used.
-
-    - persist: if unspecified, the module global gnuplot_persist is used."""
-    
-    if mouse is NotGiven:
-        mouse = gnuplot_mouse
-    if persist is NotGiven:
-        persist = gnuplot_persist
-    g = Gnuplot.Gnuplot(persist=persist)
-    if mouse:
-        g('set mouse')
-    return g
-
-# Global-level names.
-
-# A global Gnuplot instance for interactive use:
-gp = gp_new()
-
-# Accessors for the main plot object constructors:
-Data = Gnuplot.Data
-File = Gnuplot.File
-Func = Gnuplot.Func
-String = Gnuplot.String
-GridData = Gnuplot.GridData
-
-# A Unix-only function to fix eps files with bad bounding boxes (which Gnuplot
-# generates when the plot size is set to square):
-eps_fix_bbox = Gnuplot.eps_fix_bbox
-
-# String for configuring pm3d. Simply call g(pm3d_config) to execute it.  pm3d
-# is a very nice mode for plotting colormaps on surfaces. Modify the defaults
-# below to suit your taste.
-pm3d_config = """
-set pm3d solid
-set hidden3d
-unset surface
-set isosamples 50
-"""
-#******************** End of file <GnuplotRuntime.py> ******************

IPython/deathrow/PhysicalQInput.py

@@ -1,84 +0,0 b''
-# -*- coding: utf-8 -*-
-"""Modified input prompt for entering quantities with units.
-
-Modify the behavior of the interactive interpreter to allow direct input of
-quantities with units without having to make a function call.
-
-Now the following forms are accepted:
-
-x = 4 m
-y = -.45e3 m/s
-g = 9.8 m/s**2
-a = 2.3 m/s^2   # ^ -> ** automatically
-
-All other input is processed normally.
-
-Authors
--------
-- Fernando Perez <[e-mail]>
-"""
-#*****************************************************************************
-#       Copyright (C) 2008-2011 The IPython Development Team
-#       Copyright (C) 2001-2007 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.
-#*****************************************************************************
-
-# This file is an example of how to modify IPython's line-processing behavior
-# without touching the internal code. We'll define an alternate pre-processing
-# stage which allows a special form of input (which is invalid Python syntax)
-# for certain quantities, rewrites a line of proper Python in those cases, and
-# then passes it off to IPython's normal processor for further work.
-
-# With this kind of customization, IPython can be adapted for many
-# special-purpose scenarios providing alternate input syntaxes.
-
-# This file can be imported like a regular module.
-
-# IPython has a prefilter() function that analyzes each input line. We redefine
-# it here to first pre-process certain forms of input
-
-# The prototype of any alternate prefilter must be like this one (the name
-# doesn't matter):
-# - line is a string containing the user input line.
-# - continuation is a parameter which tells us if we are processing a first line of
-#   user input or the second or higher of a multi-line statement.
-
-def prefilter_PQ(self,line,continuation):
-    """Alternate prefilter for input of PhysicalQuantityInteractive objects.
-
-    This assumes that the function PhysicalQuantityInteractive() has been
-    imported."""
-
-    from re import match
-    from IPython.core.iplib import InteractiveShell
-
-    # This regexp is what does the real work
-    unit_split = match(r'\s*(\w+)\s*=\s*(-?\d*\.?\d*[eE]?-?\d*)\s+([a-zA-Z].*)',
-                       line)
-
-    # If special input was ecnountered, process it:
-    if unit_split:
-        var,val,units = unit_split.groups()
-        if var and val and units:
-            units = units.replace('^','**')
-            # Now a valid line needs to be constructed for IPython to process:
-            line = var +" = PhysicalQuantityInteractive(" + val + ", '" + \
-                   units + "')"
-            #print 'New line:',line   # dbg
-            
-    # In the end, always call the default IPython _prefilter() function.  Note
-    # that self must be passed explicitly, b/c we're calling the unbound class
-    # method (since this method will overwrite the instance prefilter())
-    return InteractiveShell._prefilter(self,line,continuation)
-
-# Rebind this to be the new IPython prefilter:
-from IPython.core.iplib import InteractiveShell
-InteractiveShell.prefilter = prefilter_PQ
-
-# Clean up the namespace.
-del InteractiveShell,prefilter_PQ
-
-# Just a heads up at the console
-print '*** Simplified input for physical quantities enabled.'

IPython/deathrow/PhysicalQInteractive.py

@@ -1,90 +0,0 b''
-# -*- coding: utf-8 -*-
-"""Modify the PhysicalQuantities class for more convenient interactive use.
-
-Also redefine some math functions to operate on PhysQties with no need for
-special method syntax. This just means moving them out to the global
-namespace.
-
-This module should always be loaded *after* math or Numeric, so it can
-overwrite math functions with the versions that handle units.
-
-Authors
--------
-- Fernando Perez <[e-mail]>
-"""
-
-#*****************************************************************************
-#       Copyright (C) 2008-2011 The IPython Development Team
-#       Copyright (C) 2001-2007 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.
-#*****************************************************************************
-
-from Scientific.Physics.PhysicalQuantities import PhysicalQuantity
-
-# This code can be set up to work with Numeric or with math for providing the
-# mathematical functions. Uncomment the one you prefer to use below.
-
-# If you use math, sin(x) won't work for x an array, only float or PhysQty
-import math
-
-# If you use Numeric, sin(x) works for x a float, PhysQty an array.
-#import Numeric as math
-
-class PhysicalQuantityFunction:
-    """Generic function wrapper for PhysicalQuantity instances.
-
-    Calls functions from either the math library or the instance's methods as
-    required.  Allows using sin(theta) or sqrt(v**2) syntax irrespective of
-    whether theta is a pure number or a PhysicalQuantity.
-
-    This is *slow*. It's meant for convenient interactive use, not for
-    speed."""
-
-    def __init__(self,name):
-        self.name = name
-        
-    def __call__(self,x):
-        if isinstance(x,PhysicalQuantity):
-            return PhysicalQuantity.__dict__[self.name](x)
-        else:
-            return math.__dict__[self.name](x)
-
-class PhysicalQuantityInteractive(PhysicalQuantity):
-    """Physical quantity with units - modified for Interactive use.
-
-    Basically, the __str__ and __repr__ methods have been swapped for more
-    convenient interactive use. Powers are shown as ^ instead of ** and only 4
-    significant figures are shown.
-
-    Also adds the following aliases for commonly used methods:
-      b = PhysicalQuantity.inBaseUnits
-      u = PhysicalQuantity.inUnitsOf
-      
-    These are useful when doing a lot of interactive calculations.
-    """
-    
-    # shorthands for the most useful unit conversions
-    b = PhysicalQuantity.inBaseUnits  # so you can just type x.b to get base units
-    u = PhysicalQuantity.inUnitsOf
-
-    # This can be done, but it can get dangerous when coupled with IPython's
-    # auto-calling. Everything ends up shown in baseunits and things like x*2
-    # get automatically converted to k(*2), which doesn't work.
-    # Probably not a good idea in general...
-    #__call__ = b
-    
-    def __str__(self):
-        return PhysicalQuantity.__repr__(self)
- 
-    def __repr__(self):
-        value = '%.4G' % self.value
-        units = self.unit.name().replace('**','^')
-        return value + ' ' + units
-
-# implement the methods defined in PhysicalQuantity as PhysicalQuantityFunctions
-sin = PhysicalQuantityFunction('sin')
-cos = PhysicalQuantityFunction('cos')
-tan = PhysicalQuantityFunction('tan')
-sqrt = PhysicalQuantityFunction('sqrt')

IPython/deathrow/Shell.py

@@ -1,42 +0,0 b''
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-A backwards compatibility layer for IPython.Shell.
-
-Previously, IPython had an IPython.Shell module.  IPython.Shell has been moved
-to IPython.core.shell and is being refactored.  This new module is provided
-for backwards compatability.  We strongly encourage everyone to start using
-the new code in IPython.core.shell.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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.
-#-----------------------------------------------------------------------------
-
-from warnings import warn
-
-msg = """
-This module (IPython.Shell) is deprecated.  The classes that were in this
-module have been replaced by:
-
-IPShell->IPython.core.iplib.InteractiveShell
-IPShellEmbed->IPython.core.embed.InteractiveShellEmbed
-
-Please migrate your code to use these classes instead.
-"""
-
-warn(msg, category=DeprecationWarning, stacklevel=1)
-
-from IPython.core.iplib import InteractiveShell as IPShell
-from IPython.core.embed import InteractiveShellEmbed as IPShellEmbed
-
-def start(user_ns=None, embedded=False):
-    """Return an instance of :class:`InteractiveShell`."""
-    if embedded:
-        return IPShellEmbed(user_ns=user_ns)
-    else:
-        return IPShell(user_ns=user_ns)
-

IPython/deathrow/astyle.py

@@ -1,400 +0,0 b''
-"""
-``astyle`` provides classes for adding style (foreground and background color;
-bold; blink; etc.) to terminal and curses output.
-"""
-
-
-import sys, os
-
-try:
-    import curses
-except ImportError:
-    curses = None
-
-
-COLOR_BLACK   = 0
-COLOR_RED     = 1
-COLOR_GREEN   = 2
-COLOR_YELLOW  = 3
-COLOR_BLUE    = 4
-COLOR_MAGENTA = 5
-COLOR_CYAN    = 6
-COLOR_WHITE   = 7
-
-A_BLINK     = 1<<0 # Blinking text
-A_BOLD      = 1<<1 # Extra bright or bold text
-A_DIM       = 1<<2 # Half bright text
-A_REVERSE   = 1<<3 # Reverse-video text
-A_STANDOUT  = 1<<4 # The best highlighting mode available
-A_UNDERLINE = 1<<5 # Underlined text
-
-
-class Style(object):
-    """
-    Store foreground color, background color and attribute (bold, underlined
-    etc.).
-    """
-    __slots__ = ("fg", "bg", "attrs")
-
-    COLORNAMES = {
-        "black": COLOR_BLACK,
-        "red": COLOR_RED,
-        "green": COLOR_GREEN,
-        "yellow": COLOR_YELLOW,
-        "blue": COLOR_BLUE,
-        "magenta": COLOR_MAGENTA,
-        "cyan": COLOR_CYAN,
-        "white": COLOR_WHITE,
-    }
-    ATTRNAMES = {
-        "blink": A_BLINK,
-        "bold": A_BOLD,
-        "dim": A_DIM,
-        "reverse": A_REVERSE,
-        "standout": A_STANDOUT,
-        "underline": A_UNDERLINE,
-    }
-
-    def __init__(self, fg, bg, attrs=0):
-        """
-        Create a ``Style`` object with ``fg`` as the foreground color,
-        ``bg`` as the background color and ``attrs`` as the attributes.
-
-        Examples:
-        >>> Style(COLOR_RED, COLOR_BLACK)
-        <Style fg=red bg=black attrs=0>
-
-        >>> Style(COLOR_YELLOW, COLOR_BLUE, A_BOLD|A_UNDERLINE)
-        <Style fg=yellow bg=blue attrs=bold|underline>
-        """
-        self.fg = fg
-        self.bg = bg
-        self.attrs = attrs
-
-    def __call__(self, *args):
-        text = Text()
-        for arg in args:
-            if isinstance(arg, Text):
-                text.extend(arg)
-            else:
-                text.append((self, arg))
-        return text
-
-    def __eq__(self, other):
-        return self.fg == other.fg and self.bg == other.bg and self.attrs == other.attrs
-
-    def __neq__(self, other):
-        return self.fg != other.fg or self.bg != other.bg or self.attrs != other.attrs
-
-    def __repr__(self):
-        color2name = ("black", "red", "green", "yellow", "blue", "magenta", "cyan", "white")
-        attrs2name = ("blink", "bold", "dim", "reverse", "standout", "underline")
-
-        return "<%s fg=%s bg=%s attrs=%s>" % (
-            self.__class__.__name__, color2name[self.fg], color2name[self.bg],
-            "|".join([attrs2name[b] for b in xrange(6) if self.attrs&(1<<b)]) or 0)
-
-    def fromstr(cls, value):
-        """
-        Create a ``Style`` object from a string. The format looks like this:
-        ``"red:black:bold|blink"``.
-        """
-        # defaults
-        fg = COLOR_WHITE
-        bg = COLOR_BLACK
-        attrs = 0
-
-        parts = value.split(":")
-        if len(parts) > 0:
-            fg = cls.COLORNAMES[parts[0].lower()]
-            if len(parts) > 1:
-                bg = cls.COLORNAMES[parts[1].lower()]
-                if len(parts) > 2:
-                    for strattr in parts[2].split("|"):
-                        attrs |= cls.ATTRNAMES[strattr.lower()]
-        return cls(fg, bg, attrs)
-    fromstr = classmethod(fromstr)
-
-    def fromenv(cls, name, default):
-        """
-        Create a ``Style`` from an environment variable named ``name``
-        (using ``default`` if the environment variable doesn't exist).
-        """
-        return cls.fromstr(os.environ.get(name, default))
-    fromenv = classmethod(fromenv)
-
-
-def switchstyle(s1, s2):
-    """
-    Return the ANSI escape sequence needed to switch from style ``s1`` to
-    style ``s2``.
-    """
-    attrmask = (A_BLINK|A_BOLD|A_UNDERLINE|A_REVERSE)
-    a1 = s1.attrs & attrmask
-    a2 = s2.attrs & attrmask
-
-    args = []
-    if s1 != s2:
-        # do we have to get rid of the bold/underline/blink bit?
-        # (can only be done by a reset)
-        # use reset when our target color is the default color
-        # (this is shorter than 37;40)
-        if (a1 & ~a2 or s2==style_default):
-            args.append("0")
-            s1 = style_default
-            a1 = 0
-
-        # now we know that old and new color have the same boldness,
-        # or the new color is bold and the old isn't,
-        # i.e. we only might have to switch bold on, not off
-        if not (a1 & A_BOLD) and (a2 & A_BOLD):
-            args.append("1")
-
-        # Fix underline
-        if not (a1 & A_UNDERLINE) and (a2 & A_UNDERLINE):
-            args.append("4")
-
-        # Fix blink
-        if not (a1 & A_BLINK) and (a2 & A_BLINK):
-            args.append("5")
-
-        # Fix reverse
-        if not (a1 & A_REVERSE) and (a2 & A_REVERSE):
-            args.append("7")
-
-        # Fix foreground color
-        if s1.fg != s2.fg:
-            args.append("3%d" % s2.fg)
-
-        # Finally fix the background color
-        if s1.bg != s2.bg:
-            args.append("4%d" % s2.bg)
-
-        if args:
-            return "\033[%sm" % ";".join(args)
-    return ""
-
-
-class Text(list):
-    """
-    A colored string. A ``Text`` object is a sequence, the sequence
-    items will be ``(style, string)`` tuples.
-    """
-
-    def __init__(self, *args):
-        list.__init__(self)
-        self.append(*args)
-
-    def __repr__(self):
-        return "%s.%s(%s)" % (
-            self.__class__.__module__, self.__class__.__name__,
-            list.__repr__(self)[1:-1])
-
-    def append(self, *args):
-        for arg in args:
-            if isinstance(arg, Text):
-                self.extend(arg)
-            elif isinstance(arg, tuple): # must be (style, string)
-                list.append(self, arg)
-            elif isinstance(arg, unicode):
-                list.append(self, (style_default, arg))
-            else:
-                list.append(self, (style_default, str(arg)))
-
-    def insert(self, index, *args):
-        self[index:index] = Text(*args)
-
-    def __add__(self, other):
-        new = Text()
-        new.append(self)
-        new.append(other)
-        return new
-
-    def __iadd__(self, other):
-        self.append(other)
-        return self
-
-    def format(self, styled=True):
-        """
-        This generator yields the strings that will make up the final
-        colorized string.
-        """
-        if styled:
-            oldstyle = style_default
-            for (style, string) in self:
-                if not isinstance(style, (int, long)):
-                    switch = switchstyle(oldstyle, style)
-                    if switch:
-                        yield switch
-                    if string:
-                        yield string
-                    oldstyle = style
-            switch = switchstyle(oldstyle, style_default)
-            if switch:
-                yield switch
-        else:
-            for (style, string) in self:
-                if not isinstance(style, (int, long)):
-                    yield string
-
-    def string(self, styled=True):
-        """
-        Return the resulting string (with escape sequences, if ``styled``
-        is true).
-        """
-        return "".join(self.format(styled))
-
-    def __str__(self):
-        """
-        Return ``self`` as a string (without ANSI escape sequences).
-        """
-        return self.string(False)
-
-    def write(self, stream, styled=True):
-        """
-        Write ``self`` to the output stream ``stream`` (with escape sequences,
-        if ``styled`` is true).
-        """
-        for part in self.format(styled):
-            stream.write(part)
-
-
-try:
-    import ipipe
-except ImportError:
-    pass
-else:
-    def xrepr_astyle_text(self, mode="default"):
-        yield (-1, True)
-        for info in self:
-            yield info
-    ipipe.xrepr.when_type(Text)(xrepr_astyle_text)
-
-
-def streamstyle(stream, styled=None):
-    """
-    If ``styled`` is ``None``, return whether ``stream`` refers to a terminal.
-    If this can't be determined (either because ``stream`` doesn't refer to a
-    real OS file, or because you're on Windows) return ``False``. If ``styled``
-    is not ``None`` ``styled`` will be returned unchanged.
-    """
-    if styled is None:
-        try:
-            styled = os.isatty(stream.fileno())
-        except (KeyboardInterrupt, SystemExit):
-            raise
-        except Exception:
-            styled = False
-    return styled
-
-
-def write(stream, styled, *texts):
-    """
-    Write ``texts`` to ``stream``.
-    """
-    text = Text(*texts)
-    text.write(stream, streamstyle(stream, styled))
-
-
-def writeln(stream, styled, *texts):
-    """
-    Write ``texts`` to ``stream`` and finish with a line feed.
-    """
-    write(stream, styled, *texts)
-    stream.write("\n")
-
-
-class Stream(object):
-    """
-    Stream wrapper that adds color output.
-    """
-    def __init__(self, stream, styled=None):
-        self.stream = stream
-        self.styled = streamstyle(stream, styled)
-
-    def write(self, *texts):
-        write(self.stream, self.styled, *texts)
-
-    def writeln(self, *texts):
-        writeln(self.stream, self.styled, *texts)
-
-    def __getattr__(self, name):
-        return getattr(self.stream, name)
-
-
-class stdout(object):
-    """
-    Stream wrapper for ``sys.stdout`` that adds color output.
-    """
-    def write(self, *texts):
-        write(sys.stdout, None, *texts)
-
-    def writeln(self, *texts):
-        writeln(sys.stdout, None, *texts)
-
-    def __getattr__(self, name):
-        return getattr(sys.stdout, name)
-stdout = stdout()
-
-
-class stderr(object):
-    """
-    Stream wrapper for ``sys.stderr`` that adds color output.
-    """
-    def write(self, *texts):
-        write(sys.stderr, None, *texts)
-
-    def writeln(self, *texts):
-        writeln(sys.stderr, None, *texts)
-
-    def __getattr__(self, name):
-        return getattr(sys.stdout, name)
-stderr = stderr()
-
-
-if curses is not None:
-    # This is probably just range(8)
-    COLOR2CURSES = [
-        COLOR_BLACK,
-        COLOR_RED,
-        COLOR_GREEN,
-        COLOR_YELLOW,
-        COLOR_BLUE,
-        COLOR_MAGENTA,
-        COLOR_CYAN,
-        COLOR_WHITE,
-    ]
-
-    A2CURSES = {
-        A_BLINK: curses.A_BLINK,
-        A_BOLD: curses.A_BOLD,
-        A_DIM: curses.A_DIM,
-        A_REVERSE: curses.A_REVERSE,
-        A_STANDOUT: curses.A_STANDOUT,
-        A_UNDERLINE: curses.A_UNDERLINE,
-    }
-
-
-# default style
-style_default = Style.fromstr("white:black")
-
-# Styles for datatypes
-style_type_none = Style.fromstr("magenta:black")
-style_type_bool = Style.fromstr("magenta:black")
-style_type_number = Style.fromstr("yellow:black")
-style_type_datetime = Style.fromstr("magenta:black")
-style_type_type = Style.fromstr("cyan:black")
-
-# Style for URLs and file/directory names
-style_url = Style.fromstr("green:black")
-style_dir = Style.fromstr("cyan:black")
-style_file = Style.fromstr("green:black")
-
-# Style for ellipsis (when an output has been shortened
-style_ellisis = Style.fromstr("red:black")
-
-# Style for displaying exceptions
-style_error = Style.fromstr("red:black")
-
-# Style for displaying non-existing attributes
-style_nodata = Style.fromstr("red:black")

IPython/deathrow/dtutils.py

@@ -1,137 +0,0 b''
-"""Doctest-related utilities for IPython.
-
-For most common uses, all you should need to run is::
-
-  from IPython.dtutils import idoctest
-
-See the idoctest docstring below for usage details.
-"""
-
-import doctest
-import sys
-
-from IPython.core import ipapi
-ip = ipapi.get()
-
-def rundoctest(text,ns=None,eraise=False):
-    """Run a the input source as a doctest, in the caller's namespace.
-
-    :Parameters:
-      text : str
-        Source to execute.
-
-    :Keywords:
-      ns : dict (None)
-        Namespace where the code should be executed.  If not given, the
-        caller's locals and globals are used.
-      eraise : bool (False)
-        If true, immediately raise any exceptions instead of reporting them at
-        the end.  This allows you to then do interactive debugging via
-        IPython's facilities (use %debug after the fact, or with %pdb for
-        automatic activation).
-    """
-
-    name = 'interactive doctest'
-    filename = '<IPython console>'
-
-    if eraise:
-        runner = doctest.DebugRunner()
-    else:
-        runner = doctest.DocTestRunner()
-        
-    parser = doctest.DocTestParser()
-    if ns is None:
-        f = sys._getframe(1)
-        ns = f.f_globals.copy()
-        ns.update(f.f_locals)
-        
-    test = parser.get_doctest(text,ns,name,filename,0)
-    runner.run(test)
-    runner.summarize(True)
-
-       
-def idoctest(ns=None,eraise=False):
-    """Interactively prompt for input and run it as a doctest.
-
-    To finish entering input, enter two blank lines or Ctrl-D (EOF).  If you
-    use Ctrl-C, the example is aborted and all input discarded.
-
-    :Keywords:
-      ns : dict (None)
-        Namespace where the code should be executed.  If not given, the IPython
-        interactive namespace is used.
-      eraise : bool (False)
-        If true, immediately raise any exceptions instead of reporting them at
-        the end.  This allows you to then do interactive debugging via
-        IPython's facilities (use %debug after the fact, or with %pdb for
-        automatic activation).
-      end_mark : str ('--')
-        String to explicitly indicate the end of input.
-
-    """
-    
-    inlines = []
-    empty_lines = 0  # count consecutive empty lines
-    run_test = True
-
-    if ns is None:
-        ns = ip.user_ns
-
-    ip.savehist()
-    try:
-        while True:
-            line = raw_input()
-            if not line or line.isspace():
-                empty_lines += 1
-            else:
-                empty_lines = 0
-
-            if empty_lines>=2:
-                break
-
-            inlines.append(line)
-    except EOFError:
-        pass
-    except KeyboardInterrupt:
-        print "KeyboardInterrupt - Discarding input."
-        run_test = False
-    
-    ip.reloadhist()
-
-    if run_test:
-        # Extra blank line at the end to ensure that the final docstring has a
-        # closing newline
-        inlines.append('')
-        rundoctest('\n'.join(inlines),ns,eraise)
-
-
-# For debugging of this module itself.
-if __name__ == "__main__":
-    t = """
-    >>> for i in range(10):
-    ...     print i,
-    ...
-    0 1 2 3 4 5 6 7 8 9
-    """
-
-    t2 = """
-        A simple example::
-
-          >>> for i in range(10):
-          ...     print i,
-          ...
-          0 1 2 3 4 5 6 7 8 9
-
-        Some more details::
-
-          >>> print "hello"
-          hello
-    """
-
-    t3 = """
-        A failing example::
-
-          >>> x=1
-          >>> x+1
-          3
-    """

IPython/deathrow/gui/wx/ipshell_nonblocking.py

@@ -1,518 +0,0 b''
-#!/usr/bin/python
-# -*- coding: iso-8859-15 -*-
-'''
-Provides IPython remote instance.
-
-@author: Laurent Dufrechou
-laurent.dufrechou _at_ gmail.com
-@license: BSD
-
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the BSD which accompanies this distribution, and
-is available at U{http://www.opensource.org/licenses/bsd-license.php}
-'''
-
-__version__ = 0.9
-__author__  = "Laurent Dufrechou"
-__email__   = "laurent.dufrechou _at_ gmail.com"
-__license__ = "BSD"
-
-import re
-import sys
-import os
-import locale
-from thread_ex import ThreadEx
-
-from IPython.core import iplib
-import IPython.utils.io
-
-##############################################################################
-class _Helper(object):
-    """Redefine the built-in 'help'.
-    This is a wrapper around pydoc.help (with a twist).
-    """
-
-    def __init__(self, pager):
-        self._pager = pager
-
-    def __repr__(self):
-        return "Type help() for interactive help, " \
-               "or help(object) for help about object."
-
-    def __call__(self, *args, **kwds):
-        class DummyWriter(object):
-            '''Dumy class to handle help output'''
-            def __init__(self, pager):
-                self._pager = pager
-
-            def write(self, data):
-                '''hook to fill self._pager'''
-                self._pager(data)
-
-        import pydoc
-        pydoc.help.output = DummyWriter(self._pager)
-        pydoc.help.interact = lambda :1
-
-        return pydoc.help(*args, **kwds)
-
-
-##############################################################################
-class _CodeExecutor(ThreadEx):
-    ''' Thread that execute ipython code '''
-    def __init__(self, instance):
-        ThreadEx.__init__(self)
-        self.instance = instance
-
-    def run(self):
-        '''Thread main loop'''
-        try:
-            self.instance._doc_text = None
-            self.instance._help_text = None
-            self.instance._execute()
-            # used for uper class to generate event after execution
-            self.instance._after_execute()
-
-        except KeyboardInterrupt:
-            pass
-
-
-##############################################################################
-class NonBlockingIPShell(object):
-    '''
-    Create an IPython instance, running the commands in a separate,
-    non-blocking thread.
-    This allows embedding in any GUI without blockage.
-
-    Note: The ThreadEx class supports asynchroneous function call
-          via raise_exc()
-    '''
-
-    def __init__(self, user_ns={}, user_global_ns=None,
-                 cin=None, cout=None, cerr=None,
-                 ask_exit_handler=None):
-        '''
-        @param user_ns: User namespace.
-        @type user_ns: dictionary
-        @param user_global_ns: User global namespace.
-        @type user_global_ns: dictionary.
-        @param cin: Console standard input.
-        @type cin: IO stream
-        @param cout: Console standard output.
-        @type cout: IO stream
-        @param cerr: Console standard error.
-        @type cerr: IO stream
-        @param exit_handler: Replacement for builtin exit() function
-        @type exit_handler: function
-        @param time_loop: Define the sleep time between two thread's loop
-        @type int
-        '''
-        #ipython0 initialisation
-        self._IP = None
-        self.init_ipython0(user_ns, user_global_ns,
-                           cin, cout, cerr,
-                           ask_exit_handler)
-
-        #vars used by _execute
-        self._iter_more = 0
-        self._history_level = 0
-        self._complete_sep =  re.compile('[\s\{\}\[\]\(\)\=]')
-        self._prompt = str(self._IP.outputcache.prompt1).strip()
-
-        #thread working vars
-        self._line_to_execute = ''
-        self._threading = True
-
-        #vars that will be checked by GUI loop to handle thread states...
-        #will be replaced later by PostEvent GUI funtions...
-        self._doc_text = None
-        self._help_text = None
-        self._add_button = None
-
-    def init_ipython0(self, user_ns={}, user_global_ns=None,
-                     cin=None, cout=None, cerr=None,
-                     ask_exit_handler=None):
-        ''' Initialize an ipython0 instance '''
-
-        #first we redefine in/out/error functions of IPython
-        #BUG: we've got a limitation form ipython0 there
-        #only one instance can be instanciated else tehre will be
-        #cin/cout/cerr clash...
-        if cin:
-            Term.cin = cin
-        if cout:
-            Term.cout = cout
-        if cerr:
-            Term.cerr = cerr
-
-        excepthook = sys.excepthook
-
-        #Hack to save sys.displayhook, because ipython seems to overwrite it...
-        self.sys_displayhook_ori = sys.displayhook
-        ipython0 = iplib.InteractiveShell(
-            parent=None, config=None,
-            user_ns=user_ns,
-            user_global_ns=user_global_ns
-        )
-        self._IP = ipython0
-
-        #we save ipython0 displayhook and we restore sys.displayhook
-        self.displayhook = sys.displayhook
-        sys.displayhook = self.sys_displayhook_ori
-
-        #we replace IPython default encoding by wx locale encoding
-        loc = locale.getpreferredencoding()
-        if loc:
-            self._IP.stdin_encoding = loc
-        #we replace the ipython default pager by our pager
-        self._IP.set_hook('show_in_pager', self._pager)
-
-        #we replace the ipython default shell command caller
-        #by our shell handler
-        self._IP.set_hook('shell_hook', self._shell)
-
-        #we replace the ipython default input command caller by our method
-        iplib.raw_input_original = self._raw_input_original
-        #we replace the ipython default exit command by our method
-        self._IP.exit = ask_exit_handler
-        #we replace the help command
-        self._IP.user_ns['help'] = _Helper(self._pager_help)
-
-        #we disable cpaste magic... until we found a way to use it properly.
-        def bypass_magic(self, arg):
-            print '%this magic is currently disabled.'
-        ipython0.define_magic('cpaste', bypass_magic)
-
-        import __builtin__
-        __builtin__.raw_input = self._raw_input
-
-        sys.excepthook = excepthook
-
-    #----------------------- Thread management section ----------------------
-    def do_execute(self, line):
-        """
-        Tell the thread to process the 'line' command
-        """
-
-        self._line_to_execute = line
-
-        if self._threading:
-            #we launch the ipython line execution in a thread to make it
-            #interruptible with include it in self namespace to be able
-            #to call  ce.raise_exc(KeyboardInterrupt)
-            self.ce = _CodeExecutor(self)
-            self.ce.start()
-        else:
-            try:
-                self._doc_text = None
-                self._help_text = None
-                self._execute()
-                # used for uper class to generate event after execution
-                self._after_execute()
-
-            except KeyboardInterrupt:
-                pass
-
-    #----------------------- IPython management section ----------------------
-    def get_threading(self):
-        """
-        Returns threading status, is set to True, then each command sent to
-        the interpreter will be executed in a separated thread allowing,
-        for example, breaking a long running commands.
-        Disallowing it, permits better compatibilty with instance that is embedding
-        IPython instance.
-
-        @return: Execution method
-        @rtype: bool
-        """
-        return self._threading
-
-    def set_threading(self, state):
-        """
-        Sets threading state, if set to True, then each command sent to
-        the interpreter will be executed in a separated thread allowing,
-        for example, breaking a long running commands.
-        Disallowing it, permits better compatibilty with instance that is embedding
-        IPython instance.
-
-        @param state: Sets threading state
-        @type bool
-        """
-        self._threading = state
-
-    def get_doc_text(self):
-        """
-        Returns the output of the processing that need to be paged (if any)
-
-        @return: The std output string.
-        @rtype: string
-        """
-        return self._doc_text
-
-    def get_help_text(self):
-        """
-        Returns the output of the processing that need to be paged via help pager(if any)
-
-        @return: The std output string.
-        @rtype: string
-        """
-        return self._help_text
-
-    def get_banner(self):
-        """
-        Returns the IPython banner for useful info on IPython instance
-
-        @return: The banner string.
-        @rtype: string
-        """
-        return self._IP.banner
-
-    def get_prompt_count(self):
-        """
-        Returns the prompt number.
-        Each time a user execute a line in the IPython shell the prompt count is increased
-
-        @return: The prompt number
-        @rtype: int
-        """
-        return self._IP.outputcache.prompt_count
-
-    def get_prompt(self):
-        """
-        Returns current prompt inside IPython instance
-        (Can be In [...]: ot ...:)
-
-        @return: The current prompt.
-        @rtype: string
-        """
-        return self._prompt
-
-    def get_indentation(self):
-        """
-        Returns the current indentation level
-        Usefull to put the caret at the good start position if we want to do autoindentation.
-
-        @return: The indentation level.
-        @rtype: int
-        """
-        return self._IP.indent_current_nsp
-
-    def update_namespace(self, ns_dict):
-        '''
-        Add the current dictionary to the shell namespace.
-
-        @param ns_dict: A dictionary of symbol-values.
-        @type ns_dict: dictionary
-        '''
-        self._IP.user_ns.update(ns_dict)
-
-    def complete(self, line):
-        '''
-        Returns an auto completed line and/or posibilities for completion.
-
-        @param line: Given line so far.
-        @type line: string
-
-        @return: Line completed as for as possible,
-        and possible further completions.
-        @rtype: tuple
-        '''
-        split_line = self._complete_sep.split(line)
-        possibilities = self._IP.complete(split_line[-1])
-        if possibilities:
-
-            def _common_prefix(str1, str2):
-                '''
-                Reduction function. returns common prefix of two given strings.
-
-                @param str1: First string.
-                @type str1: string
-                @param str2: Second string
-                @type str2: string
-
-                @return: Common prefix to both strings.
-                @rtype: string
-                '''
-                for i in range(len(str1)):
-                    if not str2.startswith(str1[:i+1]):
-                        return str1[:i]
-                return str1
-            common_prefix = reduce(_common_prefix, possibilities)
-            completed = line[:-len(split_line[-1])]+common_prefix
-        else:
-            completed = line
-        return completed, possibilities
-
-    def history_back(self):
-        '''
-        Provides one history command back.
-
-        @return: The command string.
-        @rtype: string
-        '''
-        history = ''
-        #the below while loop is used to suppress empty history lines
-        while((history == '' or history == '\n') and self._history_level >0):
-            if self._history_level >= 1:
-                self._history_level -= 1
-            history = self._get_history()
-        return history
-
-    def history_forward(self):
-        '''
-        Provides one history command forward.
-
-        @return: The command string.
-        @rtype: string
-        '''
-        history = ''
-        #the below while loop is used to suppress empty history lines
-        while((history == '' or history == '\n') \
-        and self._history_level <= self._get_history_max_index()):
-            if self._history_level < self._get_history_max_index():
-                self._history_level += 1
-                history = self._get_history()
-            else:
-                if self._history_level == self._get_history_max_index():
-                    history = self._get_history()
-                    self._history_level += 1
-                else:
-                    history = ''
-        return history
-
-    def init_history_index(self):
-        '''
-        set history to last command entered
-        '''
-        self._history_level = self._get_history_max_index()+1
-
-    #----------------------- IPython PRIVATE management section --------------
-    def _after_execute(self):
-        '''
-        Can be redefined to generate post event after excution is done
-        '''
-        pass
-
-    def _ask_exit(self):
-        '''
-        Can be redefined to generate post event to exit the Ipython shell
-        '''
-        pass
-
-    def _get_history_max_index(self):
-        '''
-        returns the max length of the history buffer
-
-        @return: history length
-        @rtype: int
-        '''
-        return len(self._IP.input_hist_raw)-1
-
-    def _get_history(self):
-        '''
-        Get's the command string of the current history level.
-
-        @return: Historic command stri
-        @rtype: string
-        '''
-        rv = self._IP.input_hist_raw[self._history_level].strip('\n')
-        return rv
-
-    def _pager_help(self, text):
-        '''
-        This function is used as a callback replacment to IPython help pager function
-
-        It puts the 'text' value inside the self._help_text string that can be retrived via
-        get_help_text function.
-        '''
-        if self._help_text == None:
-            self._help_text = text
-        else:
-            self._help_text += text
-
-    def _pager(self, IP, text):
-        '''
-        This function is used as a callback replacment to IPython pager function
-
-        It puts the 'text' value inside the self._doc_text string that can be retrived via
-        get_doc_text function.
-        '''
-        self._doc_text = text
-
-    def _raw_input_original(self, prompt=''):
-        '''
-        Custom raw_input() replacement. Get's current line from console buffer.
-
-        @param prompt: Prompt to print. Here for compatability as replacement.
-        @type prompt: string
-
-        @return: The current command line text.
-        @rtype: string
-        '''
-        return self._line_to_execute
-
-    def _raw_input(self, prompt=''):
-        """ A replacement from python's raw_input.
-        """
-        raise NotImplementedError
-
-    def _execute(self):
-        '''
-        Executes the current line provided by the shell object.
-        '''
-
-        orig_stdout = sys.stdout
-        sys.stdout = Term.cout
-        #self.sys_displayhook_ori = sys.displayhook
-        #sys.displayhook = self.displayhook
-
-        try:
-            line = self._IP.raw_input(None, self._iter_more)
-            if self._IP.autoindent:
-                self._IP.readline_startup_hook(None)
-
-        except KeyboardInterrupt:
-            self._IP.write('\nKeyboardInterrupt\n')
-            self._IP.resetbuffer()
-            # keep cache in sync with the prompt counter:
-            self._IP.outputcache.prompt_count -= 1
-
-            if self._IP.autoindent:
-                self._IP.indent_current_nsp = 0
-            self._iter_more = 0
-        except:
-            self._IP.showtraceback()
-        else:
-            self._IP.write(str(self._IP.outputcache.prompt_out).strip())
-            self._iter_more = self._IP.push_line(line)
-            if (self._IP.SyntaxTB.last_syntax_error and \
-                                                            self._IP.autoedit_syntax):
-                self._IP.edit_syntax_error()
-        if self._iter_more:
-            self._prompt = str(self._IP.outputcache.prompt2).strip()
-            if self._IP.autoindent:
-                self._IP.readline_startup_hook(self._IP.pre_readline)
-        else:
-            self._prompt = str(self._IP.outputcache.prompt1).strip()
-            self._IP.indent_current_nsp = 0 #we set indentation to 0
-
-        sys.stdout = orig_stdout
-        #sys.displayhook = self.sys_displayhook_ori
-
-    def _shell(self, ip, cmd):
-        '''
-        Replacement method to allow shell commands without them blocking.
-
-        @param ip: Ipython instance, same as self._IP
-        @type cmd: Ipython instance
-        @param cmd: Shell command to execute.
-        @type cmd: string
-        '''
-        stdin, stdout = os.popen4(cmd)
-        result = stdout.read().decode('cp437').\
-                                            encode(locale.getpreferredencoding())
-        #we use print command because the shell command is called
-        #inside IPython instance and thus is redirected to thread cout
-        #"\x01\x1b[1;36m\x02" <-- add colour to the text...
-        print "\x01\x1b[1;36m\x02"+result
-        stdout.close()
-        stdin.close()

IPython/deathrow/gui/wx/ipython_history.py

@@ -1,510 +0,0 b''
-#!/usr/bin/python
-# -*- coding: iso-8859-15 -*-
-import wx
-import wx.stc  as  stc
-import keyword
-
-#-----------------------------------------
-# History widget for IPython
-__version__ = 0.5
-__author__  = "Laurent Dufrechou"
-__email__   = "laurent.dufrechou _at_ gmail.com"
-__license__ = "BSD"
-#-----------------------------------------
-
-class IPythonHistoryPanel(wx.Panel):
-
-    def __init__(self, parent,flt_empty=True,
-                 flt_doc=True,flt_cmd=True,flt_magic=True):
-
-        wx.Panel.__init__(self,parent,-1)
-        #text_ctrl = wx.TextCtrl(self, -1, style=wx.TE_MULTILINE)
-        text_ctrl = PythonSTC(self, -1)
-
-
-        st_filt = wx.StaticText(self, -1, " Filter:")
-
-        self.filter_empty = wx.CheckBox(self, -1, "Empty commands")
-        self.filter_doc   = wx.CheckBox(self, -1, "?: Doc commands")
-        self.filter_cmd   = wx.CheckBox(self, -1, "!: Sys commands")
-        self.filter_magic = wx.CheckBox(self, -1, "%: Magic keys")
-
-        self.options={'filter_empty':{'value':'True',
-                                'checkbox':self.filter_empty, \
-                                                'True':True,'False':False,
-                                'setfunc':lambda x:None},
-                      'filter_doc':{'value':'True',
-                                'checkbox':self.filter_doc, \
-                                                'True':True,'False':False,
-                                'setfunc':lambda x:None},
-                      'filter_cmd':{'value':'True',
-                                'checkbox':self.filter_cmd, \
-                                                'True':True,'False':False,
-                                'setfunc':lambda x:None},
-                      'filter_magic':{'value':'True',
-                                'checkbox':self.filter_magic, \
-                                                'True':True,'False':False,
-                                'setfunc':lambda x:None},
-                     }
-        self.reloadOptions(self.options)
-
-        self.filter_empty.Bind(wx.EVT_CHECKBOX, self.evtCheckEmptyFilter)
-        self.filter_doc.Bind(wx.EVT_CHECKBOX, self.evtCheckDocFilter)
-        self.filter_cmd.Bind(wx.EVT_CHECKBOX, self.evtCheckCmdFilter)
-        self.filter_magic.Bind(wx.EVT_CHECKBOX, self.evtCheckMagicFilter)
-
-        #self.filter_empty.SetValue(flt_empty)
-        #self.filter_doc.SetValue(flt_doc)
-        #self.filter_cmd.SetValue(flt_cmd)
-        #self.filter_magic.SetValue(flt_magic)
-
-        sizer = wx.BoxSizer(wx.VERTICAL)
-
-        sizer.Add(text_ctrl, 1, wx.EXPAND)
-        sizer.AddMany( [(5,5),
-                        st_filt,
-                        (10,10),
-                        self.filter_empty,
-                        self.filter_doc,
-                        self.filter_cmd,
-                        self.filter_magic,
-                        (10,10),
-                        ])
-        self.SetAutoLayout(True)
-        sizer.Fit(self)
-        sizer.SetSizeHints(self)
-        self.SetSizer(sizer)
-        self.text_ctrl=text_ctrl
-        #text_ctrl.SetText(demoText + open('Main.py').read())
-        text_ctrl.EmptyUndoBuffer()
-        text_ctrl.Colourise(0, -1)
-
-        # line numbers in the margin
-        text_ctrl.SetMarginType(1, stc.STC_MARGIN_NUMBER)
-        text_ctrl.SetMarginWidth(1, 15)
-
-
-    def write(self,history_line):
-        add = True
-        if self.filter_empty.GetValue() == True and history_line == '':
-            add = False
-        if len(history_line)>0:
-            if self.filter_doc.GetValue() == True and history_line[-1:] == '?':
-                add = False
-            if self.filter_cmd.GetValue() == True and history_line[0] == '!':
-                add = False
-            if self.filter_magic.GetValue() == True and history_line[0] == '%':
-                add = False
-        if add:
-                self.text_ctrl.AppendText(history_line+'\n')
-
-#------------------------ Option Section -----------------------------------
-    def processOptionCheckedEvt(self, event, name):
-        if event.IsChecked():
-            self.options[name]['value']='True'
-        else:
-            self.options[name]['value']='False'
-        self.updateOptionTracker(name,
-                                 self.options[name]['value'])
-
-    def evtCheckEmptyFilter(self, event):
-        self.processOptionCheckedEvt(event, 'filter_empty')
-
-    def evtCheckDocFilter(self, event):
-        self.processOptionCheckedEvt(event, 'filter_doc')
-
-    def evtCheckCmdFilter(self, event):
-        self.processOptionCheckedEvt(event, 'filter_cmd')
-
-    def evtCheckMagicFilter(self, event):
-        self.processOptionCheckedEvt(event, 'filter_magic')
-
-    def getOptions(self):
-        return self.options
-
-    def reloadOptions(self,options):
-        self.options = options
-        for key in self.options.keys():
-            value = self.options[key]['value']
-            self.options[key]['checkbox'].SetValue(self.options[key][value])
-            self.options[key]['setfunc'](value)
-
-#------------------------ Hook Section -----------------------------------
-    def updateOptionTracker(self,name,value):
-        '''
-        Default history tracker (does nothing)
-        '''
-        pass
-
-    def setOptionTrackerHook(self,func):
-        '''
-        Define a new history tracker
-        '''
-        self.updateOptionTracker = func
-
-
-#----------------------------------------------------------------------
-# Font definition for Styled Text Control
-
-if wx.Platform == '__WXMSW__':
-    faces = { 'times': 'Times New Roman',
-              'mono' : 'Courier New',
-              'helv' : 'Arial',
-              'other': 'Comic Sans MS',
-              'size' : 8,
-              'size2': 6,
-             }
-elif wx.Platform == '__WXMAC__':
-    faces = { 'times': 'Times New Roman',
-              'mono' : 'Monaco',
-              'helv' : 'Arial',
-              'other': 'Comic Sans MS',
-              'size' : 8,
-              'size2': 6,
-             }
-else:
-    faces = { 'times': 'Times',
-              'mono' : 'Courier',
-              'helv' : 'Helvetica',
-              'other': 'new century schoolbook',
-              'size' : 8,
-              'size2': 6,
-             }
-
-
-#----------------------------------------------------------------------
-
-class PythonSTC(stc.StyledTextCtrl):
-
-    fold_symbols = 3
-
-    def __init__(self, parent, ID,
-                 pos=wx.DefaultPosition, size=wx.DefaultSize,
-                 style=0):
-        stc.StyledTextCtrl.__init__(self, parent, ID, pos, size, style)
-        #self.CmdKeyAssign(ord('B'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
-        #self.CmdKeyAssign(ord('N'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
-
-        self.SetLexer(stc.STC_LEX_PYTHON)
-        self.SetKeyWords(0, " ".join(keyword.kwlist))
-
-        #self.SetProperty("fold", "1")
-        #self.SetProperty("tab.timmy.whinge.level", "1")
-        #self.SetMargins(0,0)
-
-        #self.SetViewWhiteSpace(False)
-        #self.SetBufferedDraw(False)
-        #self.SetViewEOL(True)
-        self.SetEOLMode(stc.STC_EOL_CRLF)
-        #self.SetUseAntiAliasing(True)
-
-        self.SetEdgeMode(stc.STC_EDGE_LINE)
-        self.SetEdgeColumn(80)
-        self.SetEdgeColour(wx.LIGHT_GREY)
-        self.SetLayoutCache(stc.STC_CACHE_PAGE)
-
-        # Setup a margin to hold fold markers
-        #self.SetFoldFlags(16)
-        ###  WHAT IS THIS VALUE?  WHAT ARE THE OTHER FLAGS?  DOES IT MATTER?
-        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)
-        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)
-        self.SetMarginSensitive(2, True)
-        self.SetMarginWidth(2, 12)
-
-        if self.fold_symbols == 0:
-            # Arrow pointing right for contracted folders,
-            # arrow pointing down for expanded
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, \
-                                        stc.STC_MARK_ARROWDOWN, "black", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDER, \
-                                        stc.STC_MARK_ARROW, "black", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, \
-                                        stc.STC_MARK_EMPTY, "black", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, \
-                                        stc.STC_MARK_EMPTY, "black", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND, \
-                                        stc.STC_MARK_EMPTY,     "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, \
-                                        stc.STC_MARK_EMPTY,     "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, \
-                                        stc.STC_MARK_EMPTY,     "white", "black")
-
-        elif self.fold_symbols == 1:
-            # Plus for contracted folders, minus for expanded
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, \
-                                        stc.STC_MARK_MINUS, "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDER, \
-                                        stc.STC_MARK_PLUS,  "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, \
-                                        stc.STC_MARK_EMPTY, "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, \
-                                        stc.STC_MARK_EMPTY, "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND, \
-                                        stc.STC_MARK_EMPTY, "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, \
-                                        stc.STC_MARK_EMPTY, "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, \
-                                        stc.STC_MARK_EMPTY, "white", "black")
-
-        elif self.fold_symbols == 2:
-            # Like a flattened tree control using circular headers and curved joins
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,  \
-                                        stc.STC_MARK_CIRCLEMINUS, "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDER, \
-                                        stc.STC_MARK_CIRCLEPLUS, "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, \
-                                        stc.STC_MARK_VLINE, "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, \
-                                        stc.STC_MARK_LCORNERCURVE, "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND, \
-                                        stc.STC_MARK_CIRCLEPLUSCONNECTED, "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, \
-                                        stc.STC_MARK_CIRCLEMINUSCONNECTED, "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, \
-                                        stc.STC_MARK_TCORNERCURVE, "white", "#404040")
-
-        elif self.fold_symbols == 3:
-            # Like a flattened tree control using square headers
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, \
-                                        stc.STC_MARK_BOXMINUS, "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDER,  \
-                                        stc.STC_MARK_BOXPLUS, "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, \
-                                        stc.STC_MARK_VLINE, "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, \
-                                        stc.STC_MARK_LCORNER, "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,  \
-                                        stc.STC_MARK_BOXPLUSCONNECTED, "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, \
-                                        stc.STC_MARK_BOXMINUSCONNECTED, "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, \
-                                        stc.STC_MARK_TCORNER,           "white", "#808080")
-
-
-        self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdateUI)
-        self.Bind(stc.EVT_STC_MARGINCLICK, self.OnMarginClick)
-        self.Bind(wx.EVT_KEY_DOWN, self.OnKeyPressed)
-
-        # Make some styles,  The lexer defines what each style is used for, we
-        # just have to define what each style looks like.  This set is adapted from
-        # Scintilla sample property files.
-
-        # Global default styles for all languages
-        self.StyleSetSpec(stc.STC_STYLE_DEFAULT,     "face:%(helv)s,size:%(size)d" % faces)
-        self.StyleClearAll()  # Reset all to be like the default
-
-        # Global default styles for all languages
-        self.StyleSetSpec(stc.STC_STYLE_DEFAULT,     "face:%(helv)s,size:%(size)d" % faces)
-        self.StyleSetSpec(stc.STC_STYLE_LINENUMBER,  "back:#C0C0C0,face:%(helv)s,size:%(size2)d" % faces)
-        self.StyleSetSpec(stc.STC_STYLE_CONTROLCHAR, "face:%(other)s" % faces)
-        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,  "fore:#FFFFFF,back:#0000FF,bold")
-        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,    "fore:#000000,back:#FF0000,bold")
-
-        # Python styles
-        # Default
-        self.StyleSetSpec(stc.STC_P_DEFAULT, "fore:#000000,face:%(helv)s,size:%(size)d" % faces)
-        # Comments
-        self.StyleSetSpec(stc.STC_P_COMMENTLINE, "fore:#007F00,face:%(other)s,size:%(size)d" % faces)
-        # Number
-        self.StyleSetSpec(stc.STC_P_NUMBER, "fore:#007F7F,size:%(size)d" % faces)
-        # String
-        self.StyleSetSpec(stc.STC_P_STRING, "fore:#7F007F,face:%(helv)s,size:%(size)d" % faces)
-        # Single quoted string
-        self.StyleSetSpec(stc.STC_P_CHARACTER, "fore:#7F007F,face:%(helv)s,size:%(size)d" % faces)
-        # Keyword
-        self.StyleSetSpec(stc.STC_P_WORD, "fore:#00007F,bold,size:%(size)d" % faces)
-        # Triple quotes
-        self.StyleSetSpec(stc.STC_P_TRIPLE, "fore:#7F0000,size:%(size)d" % faces)
-        # Triple double quotes
-        self.StyleSetSpec(stc.STC_P_TRIPLEDOUBLE, "fore:#7F0000,size:%(size)d" % faces)
-        # Class name definition
-        self.StyleSetSpec(stc.STC_P_CLASSNAME, "fore:#0000FF,bold,underline,size:%(size)d" % faces)
-        # Function or method name definition
-        self.StyleSetSpec(stc.STC_P_DEFNAME, "fore:#007F7F,bold,size:%(size)d" % faces)
-        # Operators
-        self.StyleSetSpec(stc.STC_P_OPERATOR, "bold,size:%(size)d" % faces)
-        # Identifiers
-        self.StyleSetSpec(stc.STC_P_IDENTIFIER, "fore:#000000,face:%(helv)s,size:%(size)d" % faces)
-        # Comment-blocks
-        self.StyleSetSpec(stc.STC_P_COMMENTBLOCK, "fore:#7F7F7F,size:%(size)d" % faces)
-        # End of line where string is not closed
-        self.StyleSetSpec(stc.STC_P_STRINGEOL, "fore:#000000,face:%(mono)s,back:#E0C0E0,eol,size:%(size)d" % faces)
-
-        self.SetCaretForeground("BLUE")
-
-
-        # register some images for use in the AutoComplete box.
-        #self.RegisterImage(1, images.getSmilesBitmap())
-        #self.RegisterImage(2,
-        #    wx.ArtProvider.GetBitmap(wx.ART_NEW, size=(16,16)))
-        #self.RegisterImage(3,
-        #    wx.ArtProvider.GetBitmap(wx.ART_COPY, size=(16,16)))
-
-
-    def OnKeyPressed(self, event):
-        if self.CallTipActive():
-            self.CallTipCancel()
-        key = event.GetKeyCode()
-
-        if key == 32 and event.ControlDown():
-            pos = self.GetCurrentPos()
-
-            # Tips
-            if event.ShiftDown():
-                self.CallTipSetBackground("yellow")
-                self.CallTipShow(pos, 'lots of of text: blah, blah, blah\n\n'
-                                 'show some suff, maybe parameters..\n\n'
-                                 'fubar(param1, param2)')
-            # Code completion
-            else:
-                #lst = []
-                #for x in range(50000):
-                #    lst.append('%05d' % x)
-                #st = " ".join(lst)
-                #print len(st)
-                #self.AutoCompShow(0, st)
-
-                kw = keyword.kwlist[:]
-
-                kw.sort()  # Python sorts are case sensitive
-                self.AutoCompSetIgnoreCase(False)  # so this needs to match
-
-                # Images are specified with a appended "?type"
-                for i in range(len(kw)):
-                    if kw[i] in keyword.kwlist:
-                        kw[i] = kw[i]# + "?1"
-
-                self.AutoCompShow(0, " ".join(kw))
-        else:
-            event.Skip()
-
-
-    def OnUpdateUI(self, evt):
-        # check for matching braces
-        braceAtCaret = -1
-        braceOpposite = -1
-        charBefore = None
-        caretPos = self.GetCurrentPos()
-
-        if caretPos > 0:
-            charBefore = self.GetCharAt(caretPos - 1)
-            styleBefore = self.GetStyleAt(caretPos - 1)
-
-        # check before
-        if charBefore and chr(charBefore) in "[]{}()" and styleBefore == stc.STC_P_OPERATOR:
-            braceAtCaret = caretPos - 1
-
-        # check after
-        if braceAtCaret < 0:
-            charAfter = self.GetCharAt(caretPos)
-            styleAfter = self.GetStyleAt(caretPos)
-
-            if charAfter and chr(charAfter) in "[]{}()" and styleAfter == stc.STC_P_OPERATOR:
-                braceAtCaret = caretPos
-
-        if braceAtCaret >= 0:
-            braceOpposite = self.BraceMatch(braceAtCaret)
-
-        if braceAtCaret != -1  and braceOpposite == -1:
-            self.BraceBadLight(braceAtCaret)
-        else:
-            self.BraceHighlight(braceAtCaret, braceOpposite)
-            #pt = self.PointFromPosition(braceOpposite)
-            #self.Refresh(True, wxRect(pt.x, pt.y, 5,5))
-            #print pt
-            #self.Refresh(False)
-
-
-    def OnMarginClick(self, evt):
-        # fold and unfold as needed
-        if evt.GetMargin() == 2:
-            if evt.GetShift() and evt.GetControl():
-                self.FoldAll()
-            else:
-                lineClicked = self.LineFromPosition(evt.GetPosition())
-
-                if self.GetFoldLevel(lineClicked) & stc.STC_FOLDLEVELHEADERFLAG:
-                    if evt.GetShift():
-                        self.SetFoldExpanded(lineClicked, True)
-                        self.Expand(lineClicked, True, True, 1)
-                    elif evt.GetControl():
-                        if self.GetFoldExpanded(lineClicked):
-                            self.SetFoldExpanded(lineClicked, False)
-                            self.Expand(lineClicked, False, True, 0)
-                        else:
-                            self.SetFoldExpanded(lineClicked, True)
-                            self.Expand(lineClicked, True, True, 100)
-                    else:
-                        self.ToggleFold(lineClicked)
-
-
-    def FoldAll(self):
-        lineCount = self.GetLineCount()
-        expanding = True
-
-        # find out if we are folding or unfolding
-        for lineNum in range(lineCount):
-            if self.GetFoldLevel(lineNum) & stc.STC_FOLDLEVELHEADERFLAG:
-                expanding = not self.GetFoldExpanded(lineNum)
-                break
-
-        lineNum = 0
-
-        while lineNum < lineCount:
-            level = self.GetFoldLevel(lineNum)
-            if level & stc.STC_FOLDLEVELHEADERFLAG and \
-               (level & stc.STC_FOLDLEVELNUMBERMASK) == stc.STC_FOLDLEVELBASE:
-
-                if expanding:
-                    self.SetFoldExpanded(lineNum, True)
-                    lineNum = self.Expand(lineNum, True)
-                    lineNum = lineNum - 1
-                else:
-                    lastChild = self.GetLastChild(lineNum, -1)
-                    self.SetFoldExpanded(lineNum, False)
-
-                    if lastChild > lineNum:
-                        self.HideLines(lineNum+1, lastChild)
-
-            lineNum = lineNum + 1
-
-
-
-    def Expand(self, line, doExpand, force=False, visLevels=0, level=-1):
-        lastChild = self.GetLastChild(line, level)
-        line = line + 1
-
-        while line <= lastChild:
-            if force:
-                if visLevels > 0:
-                    self.ShowLines(line, line)
-                else:
-                    self.HideLines(line, line)
-            else:
-                if doExpand:
-                    self.ShowLines(line, line)
-
-            if level == -1:
-                level = self.GetFoldLevel(line)
-
-            if level & stc.STC_FOLDLEVELHEADERFLAG:
-                if force:
-                    if visLevels > 1:
-                        self.SetFoldExpanded(line, True)
-                    else:
-                        self.SetFoldExpanded(line, False)
-
-                    line = self.Expand(line, doExpand, force, visLevels-1)
-
-                else:
-                    if doExpand and self.GetFoldExpanded(line):
-                        line = self.Expand(line, True, force, visLevels-1)
-                    else:
-                        line = self.Expand(line, False, force, visLevels-1)
-            else:
-                line = line + 1
-
-        return line
-
-
-#----------------------------------------------------------------------

IPython/deathrow/gui/wx/ipython_view.py

@@ -1,942 +0,0 b''
-#!/usr/bin/python
-# -*- coding: utf-8 -*-
-'''
-Provides IPython WX console widgets.
-
-@author: Laurent Dufrechou
-laurent.dufrechou _at_ gmail.com
-This WX widget is based on the original work of Eitan Isaacson
-that provided the console for the GTK toolkit.
-
-Original work from:
-@author: Eitan Isaacson
-@organization: IBM Corporation
-@copyright: Copyright (c) 2007 IBM Corporation
-@license: BSD
-
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the BSD which accompanies this distribution, and
-is available at U{http://www.opensource.org/licenses/bsd-license.php}
-'''
-
-__version__ = 0.9
-__author__  = "Laurent Dufrechou"
-__email__   = "laurent.dufrechou _at_ gmail.com"
-__license__ = "BSD"
-
-import wx
-import wx.stc  as  stc
-
-import re
-from StringIO import StringIO
-
-import sys
-import codecs
-import locale
-import time
-
-for enc in (locale.getpreferredencoding(),
-            sys.getfilesystemencoding(),
-            sys.getdefaultencoding()):
-    try:
-        codecs.lookup(enc)
-        ENCODING = enc
-        break
-    except LookupError:
-        pass
-else:
-    ENCODING = 'utf-8'
-
-from ipshell_nonblocking import NonBlockingIPShell
-
-class WxNonBlockingIPShell(NonBlockingIPShell):
-    '''
-    An NonBlockingIPShell Thread that is WX dependent.
-    '''
-    def __init__(self, parent,
-                 argv=[],user_ns={},user_global_ns=None,
-                 cin=None, cout=None, cerr=None,
-                 ask_exit_handler=None):
-
-        NonBlockingIPShell.__init__(self, argv, user_ns, user_global_ns,
-                                    cin, cout, cerr,
-                                    ask_exit_handler)
-
-        self.parent = parent
-
-        self.ask_exit_callback = ask_exit_handler
-        self._IP.exit = self._ask_exit
-
-    def addGUIShortcut(self, text, func):
-        wx.CallAfter(self.parent.add_button_handler,
-                button_info={   'text':text,
-                                'func':self.parent.doExecuteLine(func)})
-
-    def _raw_input(self, prompt=''):
-        """ A replacement from python's raw_input.
-        """
-        self.answer = None
-        if(self._threading == True):
-                        wx.CallAfter(self._yesNoBox,  prompt)
-                        while self.answer is None:
-                                time.sleep(.1)
-        else:
-                        self._yesNoBox(prompt)
-        return self.answer
-
-    def _yesNoBox(self, prompt):
-        """ yes/no box managed with wx.CallAfter jsut in case caler is executed in a thread"""
-        dlg = wx.TextEntryDialog(
-                self.parent, prompt,
-                'Input requested', 'Python')
-        dlg.SetValue("")
-
-        answer = ''
-        if dlg.ShowModal() == wx.ID_OK:
-            answer = dlg.GetValue()
-
-        dlg.Destroy()
-        self.answer = answer
-
-    def _ask_exit(self):
-        wx.CallAfter(self.ask_exit_callback, ())
-
-    def _after_execute(self):
-        wx.CallAfter(self.parent.evtStateExecuteDone, ())
-
-
-class WxConsoleView(stc.StyledTextCtrl):
-    '''
-    Specialized styled text control view for console-like workflow.
-    We use here a scintilla frontend thus it can be reused in any GUI that
-    supports scintilla with less work.
-
-    @cvar ANSI_COLORS_BLACK: Mapping of terminal colors to X11 names.
-                    (with Black background)
-    @type ANSI_COLORS_BLACK: dictionary
-
-    @cvar ANSI_COLORS_WHITE: Mapping of terminal colors to X11 names.
-                    (with White background)
-    @type ANSI_COLORS_WHITE: dictionary
-
-    @ivar color_pat: Regex of terminal color pattern
-    @type color_pat: _sre.SRE_Pattern
-    '''
-    ANSI_STYLES_BLACK = {'0;30': [0, 'WHITE'],            '0;31': [1, 'RED'],
-                         '0;32': [2, 'GREEN'],            '0;33': [3, 'BROWN'],
-                         '0;34': [4, 'BLUE'],             '0;35': [5, 'PURPLE'],
-                         '0;36': [6, 'CYAN'],             '0;37': [7, 'LIGHT GREY'],
-                         '1;30': [8, 'DARK GREY'],        '1;31': [9, 'RED'],
-                         '1;32': [10, 'SEA GREEN'],       '1;33': [11, 'YELLOW'],
-                         '1;34': [12, 'LIGHT BLUE'],      '1;35':
-                                                          [13, 'MEDIUM VIOLET RED'],
-                         '1;36': [14, 'LIGHT STEEL BLUE'], '1;37': [15, 'YELLOW']}
-
-    ANSI_STYLES_WHITE = {'0;30': [0, 'BLACK'],            '0;31': [1, 'RED'],
-                         '0;32': [2, 'GREEN'],            '0;33': [3, 'BROWN'],
-                         '0;34': [4, 'BLUE'],             '0;35': [5, 'PURPLE'],
-                         '0;36': [6, 'CYAN'],             '0;37': [7, 'LIGHT GREY'],
-                         '1;30': [8, 'DARK GREY'],        '1;31': [9, 'RED'],
-                         '1;32': [10, 'SEA GREEN'],       '1;33': [11, 'YELLOW'],
-                         '1;34': [12, 'LIGHT BLUE'],      '1;35':
-                                                           [13, 'MEDIUM VIOLET RED'],
-                         '1;36': [14, 'LIGHT STEEL BLUE'], '1;37': [15, 'YELLOW']}
-
-    def __init__(self, parent, prompt, intro="", background_color="BLACK",
-                 pos=wx.DefaultPosition, ID = -1, size=wx.DefaultSize,
-                 style=0, autocomplete_mode = 'IPYTHON'):
-        '''
-        Initialize console view.
-
-        @param parent: Parent widget
-        @param prompt: User specified prompt
-        @type intro: string
-        @param intro: User specified startup introduction string
-        @type intro: string
-        @param background_color: Can be BLACK or WHITE
-        @type background_color: string
-        @param other: init param of styledTextControl (can be used as-is)
-        @param autocomplete_mode: Can be 'IPYTHON' or 'STC'
-            'IPYTHON' show autocompletion the ipython way
-            'STC" show it scintilla text control way
-        '''
-        stc.StyledTextCtrl.__init__(self, parent, ID, pos, size, style)
-
-        ####### Scintilla configuration ###################################
-
-        # Ctrl + B or Ctrl + N can be used to zoomin/zoomout the text inside
-        # the widget
-        self.CmdKeyAssign(ord('B'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
-        self.CmdKeyAssign(ord('N'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
-
-        #We draw a line at position 80
-        self.SetEdgeMode(stc.STC_EDGE_LINE)
-        self.SetEdgeColumn(80)
-        self.SetEdgeColour(wx.LIGHT_GREY)
-
-        #self.SetViewWhiteSpace(True)
-        #self.SetViewEOL(True)
-        self.SetEOLMode(stc.STC_EOL_CRLF)
-        #self.SetWrapMode(stc.STC_WRAP_CHAR)
-        #self.SetWrapMode(stc.STC_WRAP_WORD)
-        self.SetBufferedDraw(True)
-        #self.SetUseAntiAliasing(True)
-        self.SetLayoutCache(stc.STC_CACHE_PAGE)
-        self.SetUndoCollection(False)
-        self.SetUseTabs(True)
-        self.SetIndent(4)
-        self.SetTabWidth(4)
-
-        self.EnsureCaretVisible()
-
-        self.SetMargins(3, 3) #text is moved away from border with 3px
-        # Suppressing Scintilla margins
-        self.SetMarginWidth(0, 0)
-        self.SetMarginWidth(1, 0)
-        self.SetMarginWidth(2, 0)
-
-        self.background_color = background_color
-        self.buildStyles()
-
-        self.indent = 0
-        self.prompt_count = 0
-        self.color_pat = re.compile('\x01?\x1b\[(.*?)m\x02?')
-
-        self.write(intro)
-        self.setPrompt(prompt)
-        self.showPrompt()
-
-        self.autocomplete_mode = autocomplete_mode
-
-        self.Bind(wx.EVT_KEY_DOWN, self._onKeypress)
-
-    def buildStyles(self):
-        #we define platform specific fonts
-        if wx.Platform == '__WXMSW__':
-            faces = { 'times': 'Times New Roman',
-                      'mono' : 'Courier New',
-                      'helv' : 'Arial',
-                      'other': 'Comic Sans MS',
-                      'size' : 10,
-                      'size2': 8,
-                     }
-        elif wx.Platform == '__WXMAC__':
-            faces = { 'times': 'Times New Roman',
-                      'mono' : 'Monaco',
-                      'helv' : 'Arial',
-                      'other': 'Comic Sans MS',
-                      'size' : 10,
-                      'size2': 8,
-                     }
-        else:
-            faces = { 'times': 'Times',
-                      'mono' : 'Courier',
-                      'helv' : 'Helvetica',
-                      'other': 'new century schoolbook',
-                      'size' : 10,
-                      'size2': 8,
-                     }
-
-        # make some styles
-        if self.background_color != "BLACK":
-            self.background_color = "WHITE"
-            self.SetCaretForeground("BLACK")
-            self.ANSI_STYLES = self.ANSI_STYLES_WHITE
-        else:
-            self.SetCaretForeground("WHITE")
-            self.ANSI_STYLES = self.ANSI_STYLES_BLACK
-
-        self.StyleSetSpec(stc.STC_STYLE_DEFAULT,
-                          "fore:%s,back:%s,size:%d,face:%s"
-                                    % (self.ANSI_STYLES['0;30'][1],
-                          self.background_color,
-                          faces['size'], faces['mono']))
-        self.StyleClearAll()
-        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,
-                          "fore:#FF0000,back:#0000FF,bold")
-        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,
-                          "fore:#000000,back:#FF0000,bold")
-
-        for style in self.ANSI_STYLES.values():
-            self.StyleSetSpec(style[0], "bold,fore:%s" % style[1])
-
-        #######################################################################
-
-    def setBackgroundColor(self, color):
-        self.background_color = color
-        self.buildStyles()
-
-    def getBackgroundColor(self, color):
-        return self.background_color
-
-    def asyncWrite(self, text):
-        '''
-        Write given text to buffer in an asynchroneous way.
-        It is used from another thread to be able to acces the GUI.
-        @param text: Text to append
-        @type text: string
-        '''
-        try:
-            wx.MutexGuiEnter()
-
-            #be sure not to be interrutpted before the MutexGuiLeave!
-            self.write(text)
-
-        except KeyboardInterrupt:
-            wx.MutexGuiLeave()
-            raise KeyboardInterrupt
-        wx.MutexGuiLeave()
-
-
-    def write(self, text):
-        '''
-        Write given text to buffer.
-
-        @param text: Text to append.
-        @type text: string
-        '''
-        segments = self.color_pat.split(text)
-        segment = segments.pop(0)
-        self.StartStyling(self.getCurrentLineEnd(), 0xFF)
-        self.AppendText(segment)
-
-        if segments:
-            ansi_tags = self.color_pat.findall(text)
-
-            for tag in ansi_tags:
-                i = segments.index(tag)
-                self.StartStyling(self.getCurrentLineEnd(), 0xFF)
-                self.AppendText(segments[i+1])
-
-                if tag != '0':
-                    self.SetStyling(len(segments[i+1]), self.ANSI_STYLES[tag][0])
-
-                segments.pop(i)
-
-        self.moveCursor(self.getCurrentLineEnd())
-
-    def getPromptLen(self):
-        '''
-        Return the length of current prompt
-        '''
-        return len(str(self.prompt_count)) + 7
-
-    def setPrompt(self, prompt):
-        self.prompt = prompt
-
-    def setIndentation(self, indentation):
-        self.indent = indentation
-
-    def setPromptCount(self, count):
-        self.prompt_count = count
-
-    def showPrompt(self):
-        '''
-        Prints prompt at start of line.
-
-        @param prompt: Prompt to print.
-        @type prompt: string
-        '''
-        self.write(self.prompt)
-        #now we update the position of end of prompt
-        self.current_start = self.getCurrentLineEnd()
-
-        autoindent = self.indent*' '
-        autoindent = autoindent.replace('    ','\t')
-        self.write(autoindent)
-
-    def changeLine(self, text):
-        '''
-        Replace currently entered command line with given text.
-
-        @param text: Text to use as replacement.
-        @type text: string
-        '''
-        self.SetSelection(self.getCurrentPromptStart(), self.getCurrentLineEnd())
-        self.ReplaceSelection(text)
-        self.moveCursor(self.getCurrentLineEnd())
-
-    def getCurrentPromptStart(self):
-        return self.current_start
-
-    def getCurrentLineStart(self):
-        return self.GotoLine(self.LineFromPosition(self.GetCurrentPos()))
-
-    def getCurrentLineEnd(self):
-        return self.GetLength()
-
-    def getCurrentLine(self):
-        '''
-        Get text in current command line.
-
-        @return: Text of current command line.
-        @rtype: string
-        '''
-        return self.GetTextRange(self.getCurrentPromptStart(),
-                                 self.getCurrentLineEnd())
-
-    def moveCursorOnNewValidKey(self):
-        #If cursor is at wrong position put it at last line...
-        if self.GetCurrentPos() < self.getCurrentPromptStart():
-            self.GotoPos(self.getCurrentPromptStart())
-
-    def removeFromTo(self, from_pos, to_pos):
-        if from_pos < to_pos:
-            self.SetSelection(from_pos, to_pos)
-            self.DeleteBack()
-
-    def removeCurrentLine(self):
-        self.LineDelete()
-
-    def moveCursor(self, position):
-        self.GotoPos(position)
-
-    def getCursorPos(self):
-        return self.GetCurrentPos()
-
-    def selectFromTo(self, from_pos, to_pos):
-        self.SetSelectionStart(from_pos)
-        self.SetSelectionEnd(to_pos)
-
-    def writeHistory(self, history):
-        self.removeFromTo(self.getCurrentPromptStart(), self.getCurrentLineEnd())
-        self.changeLine(history)
-
-    def setCompletionMethod(self, completion):
-        if completion in ['IPYTHON', 'STC']:
-            self.autocomplete_mode = completion
-        else:
-            raise AttributeError
-
-    def getCompletionMethod(self, completion):
-        return self.autocomplete_mode
-
-    def writeCompletion(self, possibilities):
-        if self.autocomplete_mode == 'IPYTHON':
-            max_len = len(max(possibilities, key=len))
-            max_symbol = ' '*max_len
-
-            #now we check how much symbol we can put on a line...
-            test_buffer = max_symbol + ' '*4
-
-            allowed_symbols = 80/len(test_buffer)
-            if allowed_symbols == 0:
-                allowed_symbols = 1
-
-            pos = 1
-            buf = ''
-            for symbol in possibilities:
-                #buf += symbol+'\n'#*spaces)
-                if pos < allowed_symbols:
-                    spaces = max_len - len(symbol) + 4
-                    buf += symbol+' '*spaces
-                    pos += 1
-                else:
-                    buf += symbol+'\n'
-                    pos = 1
-            self.write(buf)
-        else:
-            possibilities.sort()  # Python sorts are case sensitive
-            self.AutoCompSetIgnoreCase(False)
-            self.AutoCompSetAutoHide(False)
-            #let compute the length ot last word
-            splitter = [' ', '(', '[', '{','=']
-            last_word = self.getCurrentLine()
-            for breaker in splitter:
-                last_word = last_word.split(breaker)[-1]
-            self.AutoCompShow(len(last_word), " ".join(possibilities))
-
-    def _onKeypress(self, event, skip=True):
-        '''
-        Key press callback used for correcting behavior for console-like
-        interfaces. For example 'home' should go to prompt, not to begining of
-        line.
-
-        @param widget: Widget that key press accored in.
-        @type widget: gtk.Widget
-        @param event: Event object
-        @type event: gtk.gdk.Event
-
-        @return: Return True if event as been catched.
-        @rtype: boolean
-        '''
-        if not self.AutoCompActive():
-            if event.GetKeyCode() == wx.WXK_HOME:
-                if event.Modifiers == wx.MOD_NONE:
-                    self.moveCursorOnNewValidKey()
-                    self.moveCursor(self.getCurrentPromptStart())
-                    return True
-                elif event.Modifiers == wx.MOD_SHIFT:
-                    self.moveCursorOnNewValidKey()
-                    self.selectFromTo(self.getCurrentPromptStart(), self.getCursorPos())
-                    return True
-                else:
-                    return False
-
-            elif event.GetKeyCode() == wx.WXK_LEFT:
-                if event.Modifiers == wx.MOD_NONE:
-                    self.moveCursorOnNewValidKey()
-
-                    self.moveCursor(self.getCursorPos()-1)
-                    if self.getCursorPos() < self.getCurrentPromptStart():
-                        self.moveCursor(self.getCurrentPromptStart())
-                    return True
-
-            elif event.GetKeyCode() == wx.WXK_BACK:
-                self.moveCursorOnNewValidKey()
-                if self.getCursorPos() > self.getCurrentPromptStart():
-                    event.Skip()
-                return True
-
-            if skip:
-                if event.GetKeyCode() not in [wx.WXK_PAGEUP, wx.WXK_PAGEDOWN]\
-                and event.Modifiers == wx.MOD_NONE:
-                    self.moveCursorOnNewValidKey()
-
-                event.Skip()
-                return True
-            return False
-        else:
-            event.Skip()
-
-    def OnUpdateUI(self, evt):
-        # check for matching braces
-        braceAtCaret = -1
-        braceOpposite = -1
-        charBefore = None
-        caretPos = self.GetCurrentPos()
-
-        if caretPos > 0:
-            charBefore = self.GetCharAt(caretPos - 1)
-            styleBefore = self.GetStyleAt(caretPos - 1)
-
-        # check before
-        if charBefore and chr(charBefore) in "[]{}()" and styleBefore == stc.STC_P_OPERATOR:
-            braceAtCaret = caretPos - 1
-
-        # check after
-        if braceAtCaret < 0:
-            charAfter = self.GetCharAt(caretPos)
-            styleAfter = self.GetStyleAt(caretPos)
-
-            if charAfter and chr(charAfter) in "[]{}()" and styleAfter == stc.STC_P_OPERATOR:
-                braceAtCaret = caretPos
-
-        if braceAtCaret >= 0:
-            braceOpposite = self.BraceMatch(braceAtCaret)
-
-        if braceAtCaret != -1  and braceOpposite == -1:
-            self.BraceBadLight(braceAtCaret)
-        else:
-            self.BraceHighlight(braceAtCaret, braceOpposite)
-            #pt = self.PointFromPosition(braceOpposite)
-            #self.Refresh(True, wxRect(pt.x, pt.y, 5,5))
-            #print pt
-            #self.Refresh(False)
-
-class IPShellWidget(wx.Panel):
-    '''
-    This is wx.Panel that embbed the IPython Thread and the wx.StyledTextControl
-    If you want to port this to any other GUI toolkit, just replace the
-    WxConsoleView by YOURGUIConsoleView and make YOURGUIIPythonView derivate
-    from whatever container you want. I've choosed to derivate from a wx.Panel
-    because it seems to be more useful
-    Any idea to make it more 'generic' welcomed.
-    '''
-
-    def __init__(self, parent, intro=None,
-                 background_color="BLACK", add_button_handler=None,
-                 wx_ip_shell=None, user_ns={},user_global_ns=None,
-                 ):
-        '''
-        Initialize.
-        Instanciate an IPython thread.
-        Instanciate a WxConsoleView.
-        Redirect I/O to console.
-        '''
-        wx.Panel.__init__(self,parent,wx.ID_ANY)
-
-        self.parent = parent
-        ### IPython non blocking shell instanciation ###
-        self.cout = StringIO()
-        self.add_button_handler = add_button_handler
-
-        if wx_ip_shell is not None:
-            self.IP = wx_ip_shell
-        else:
-            self.IP = WxNonBlockingIPShell(self,
-                                    cout = self.cout, cerr = self.cout,
-                                    ask_exit_handler = self.askExitCallback)
-
-        ### IPython wx console view instanciation ###
-        #If user didn't defined an intro text, we create one for him
-        #If you really wnat an empty intro just call wxIPythonViewPanel
-        #with intro=''
-        if intro is None:
-            welcome_text = "Welcome to WxIPython Shell.\n\n"
-            welcome_text+= self.IP.get_banner()
-            welcome_text+= "!command  -> Execute command in shell\n"
-            welcome_text+= "TAB       -> Autocompletion\n"
-        else:
-            welcome_text = intro
-
-        self.text_ctrl = WxConsoleView(self,
-                                       self.IP.get_prompt(),
-                                       intro=welcome_text,
-                                       background_color=background_color)
-
-        option_text = wx.StaticText(self, -1, "Options:")
-        self.completion_option = wx.CheckBox(self, -1, "Scintilla Completion")
-        self.completion_option.SetToolTip(wx.ToolTip(
-            "Selects the completion type:\nEither Ipython default style or Scintilla one"))
-        #self.completion_option.SetValue(False)
-        self.background_option = wx.CheckBox(self, -1, "White Background")
-        self.background_option.SetToolTip(wx.ToolTip(
-            "Selects the back ground color: BLACK or WHITE"))
-        #self.background_option.SetValue(False)
-        self.threading_option = wx.CheckBox(self, -1, "Execute in thread")
-        self.threading_option.SetToolTip(wx.ToolTip(
-            "Use threading: infinite loop don't freeze the GUI and commands can be breaked\nNo  threading: maximum compatibility"))
-        #self.threading_option.SetValue(False)
-
-        self.options={'completion':{'value':'IPYTHON',
-                                    'checkbox':self.completion_option,'STC':True,'IPYTHON':False,
-                                    'setfunc':self.text_ctrl.setCompletionMethod},
-                      'background_color':{'value':'BLACK',
-                                          'checkbox':self.background_option,'WHITE':True,'BLACK':False,
-                                          'setfunc':self.text_ctrl.setBackgroundColor},
-                      'threading':{'value':'True',
-                                   'checkbox':self.threading_option,'True':True,'False':False,
-                                   'setfunc':self.IP.set_threading},
-                     }
-
-        #self.cout.write dEfault option is asynchroneous because default sate is threading ON
-        self.cout.write = self.text_ctrl.asyncWrite
-        #we reloard options
-        self.reloadOptions(self.options)
-
-        self.text_ctrl.Bind(wx.EVT_KEY_DOWN, self.keyPress)
-        self.completion_option.Bind(wx.EVT_CHECKBOX, self.evtCheckOptionCompletion)
-        self.background_option.Bind(wx.EVT_CHECKBOX, self.evtCheckOptionBackgroundColor)
-        self.threading_option.Bind(wx.EVT_CHECKBOX, self.evtCheckOptionThreading)
-
-        ### making the layout of the panel ###
-        sizer = wx.BoxSizer(wx.VERTICAL)
-        sizer.Add(self.text_ctrl, 1, wx.EXPAND)
-        option_sizer = wx.BoxSizer(wx.HORIZONTAL)
-        sizer.Add(option_sizer, 0)
-        option_sizer.AddMany([(10, 20),
-                              (option_text, 0, wx.ALIGN_CENTER_VERTICAL),
-                              (5, 5),
-                              (self.completion_option, 0, wx.ALIGN_CENTER_VERTICAL),
-                              (8, 8),
-                              (self.background_option, 0, wx.ALIGN_CENTER_VERTICAL),
-                              (8, 8),
-                              (self.threading_option, 0, wx.ALIGN_CENTER_VERTICAL)
-                              ])
-        self.SetAutoLayout(True)
-        sizer.Fit(self)
-        sizer.SetSizeHints(self)
-        self.SetSizer(sizer)
-        #and we focus on the widget :)
-        self.SetFocus()
-
-        #widget state management (for key handling different cases)
-        self.setCurrentState('IDLE')
-        self.pager_state = 'DONE'
-        self.raw_input_current_line = 0
-
-    def askExitCallback(self, event):
-        self.askExitHandler(event)
-
-    #---------------------- IPython Thread Management ------------------------
-    def stateDoExecuteLine(self):
-        lines=self.text_ctrl.getCurrentLine()
-        self.text_ctrl.write('\n')
-        lines_to_execute = lines.replace('\t',' '*4)
-        lines_to_execute = lines_to_execute.replace('\r','')
-        self.IP.do_execute(lines_to_execute.encode(ENCODING))
-        self.updateHistoryTracker(lines)
-        if(self.text_ctrl.getCursorPos()!=0):
-            self.text_ctrl.removeCurrentLine()
-        self.setCurrentState('WAIT_END_OF_EXECUTION')
-
-    def evtStateExecuteDone(self,evt):
-        self.doc = self.IP.get_doc_text()
-        self.help = self.IP.get_help_text()
-        if self.doc:
-            self.pager_lines = self.doc[7:].split('\n')
-            self.pager_state = 'INIT'
-            self.setCurrentState('SHOW_DOC')
-            self.pager(self.doc)
-        elif self.help:
-            self.pager_lines = self.help.split('\n')
-            self.pager_state = 'INIT'
-            self.setCurrentState('SHOW_DOC')
-            self.pager(self.help)
-        else:
-            if(self.text_ctrl.getCursorPos()!=0):
-                self.text_ctrl.removeCurrentLine()
-            self.stateShowPrompt()
-
-    def stateShowPrompt(self):
-        self.setCurrentState('SHOW_PROMPT')
-        self.text_ctrl.setPrompt(self.IP.get_prompt())
-        self.text_ctrl.setIndentation(self.IP.get_indentation())
-        self.text_ctrl.setPromptCount(self.IP.get_prompt_count())
-        self.text_ctrl.showPrompt()
-        self.IP.init_history_index()
-        self.setCurrentState('IDLE')
-
-    def setCurrentState(self, state):
-        self.cur_state = state
-        self.updateStatusTracker(self.cur_state)
-
-    def pager(self,text):
-
-        if self.pager_state == 'INIT':
-            #print >>sys.__stdout__,"PAGER state:",self.pager_state
-            self.pager_nb_lines = len(self.pager_lines)
-            self.pager_index = 0
-            self.pager_do_remove = False
-            self.text_ctrl.write('\n')
-            self.pager_state = 'PROCESS_LINES'
-
-        if self.pager_state == 'PROCESS_LINES':
-            #print >>sys.__stdout__,"PAGER state:",self.pager_state
-            if self.pager_do_remove == True:
-                self.text_ctrl.removeCurrentLine()
-                self.pager_do_remove = False
-
-            if self.pager_nb_lines > 10:
-                #print >>sys.__stdout__,"PAGER processing 10 lines"
-                if self.pager_index > 0:
-                    self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
-                else:
-                    self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
-
-                for line in self.pager_lines[self.pager_index+1:self.pager_index+9]:
-                    self.text_ctrl.write("\x01\x1b[1;36m\x02 "+line+'\n')
-                self.pager_index += 10
-                self.pager_nb_lines -= 10
-                self.text_ctrl.write("--- Push Enter to continue or 'Q' to quit---")
-                self.pager_do_remove = True
-                self.pager_state = 'WAITING'
-                return
-            else:
-                #print >>sys.__stdout__,"PAGER processing last lines"
-                if self.pager_nb_lines > 0:
-                    if self.pager_index > 0:
-                        self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
-                    else:
-                        self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
-
-                    self.pager_index += 1
-                    self.pager_nb_lines -= 1
-                if self.pager_nb_lines > 0:
-                    for line in self.pager_lines[self.pager_index:]:
-                        self.text_ctrl.write("\x01\x1b[1;36m\x02 "+line+'\n')
-                        self.pager_nb_lines = 0
-                self.pager_state = 'DONE'
-                self.stateShowPrompt()
-
-    #------------------------ Key Handler ------------------------------------
-    def keyPress(self, event):
-        '''
-        Key press callback with plenty of shell goodness, like history,
-        autocompletions, etc.
-        '''
-        if event.GetKeyCode() == ord('C'):
-            if event.Modifiers == wx.MOD_CONTROL or event.Modifiers == wx.MOD_ALT:
-                if self.cur_state == 'WAIT_END_OF_EXECUTION':
-                    #we raise an exception inside the IPython thread container
-                    self.IP.ce.raise_exc(KeyboardInterrupt)
-                    return
-
-        #let this before 'wx.WXK_RETURN' because we have to put 'IDLE'
-        #mode if AutoComp has been set as inactive
-        if self.cur_state == 'COMPLETING':
-            if not self.text_ctrl.AutoCompActive():
-                self.cur_state = 'IDLE'
-            else:
-                event.Skip()
-
-        if event.KeyCode == wx.WXK_RETURN:
-            if self.cur_state == 'IDLE':
-                #we change the state ot the state machine
-                self.setCurrentState('DO_EXECUTE_LINE')
-                self.stateDoExecuteLine()
-                return
-
-            if self.pager_state == 'WAITING':
-                self.pager_state = 'PROCESS_LINES'
-                self.pager(self.doc)
-                return
-
-            if self.cur_state == 'WAITING_USER_INPUT':
-                line=self.text_ctrl.getCurrentLine()
-                self.text_ctrl.write('\n')
-                self.setCurrentState('WAIT_END_OF_EXECUTION')
-                return
-
-        if event.GetKeyCode() in [ord('q'),ord('Q')]:
-            if self.pager_state == 'WAITING':
-                self.pager_state = 'DONE'
-                self.text_ctrl.write('\n')
-                self.stateShowPrompt()
-                return
-
-        if self.cur_state == 'WAITING_USER_INPUT':
-            event.Skip()
-
-        if self.cur_state == 'IDLE':
-            if event.KeyCode == wx.WXK_UP:
-                history = self.IP.history_back()
-                self.text_ctrl.writeHistory(history)
-                return
-            if event.KeyCode == wx.WXK_DOWN:
-                history = self.IP.history_forward()
-                self.text_ctrl.writeHistory(history)
-                return
-            if event.KeyCode == wx.WXK_TAB:
-                #if line empty we disable tab completion
-                if not self.text_ctrl.getCurrentLine().strip():
-                    self.text_ctrl.write('\t')
-                    return
-                completed, possibilities = self.IP.complete(self.text_ctrl.getCurrentLine())
-                if len(possibilities) > 1:
-                    if self.text_ctrl.autocomplete_mode == 'IPYTHON':
-                        cur_slice = self.text_ctrl.getCurrentLine()
-                        self.text_ctrl.write('\n')
-                        self.text_ctrl.writeCompletion(possibilities)
-                        self.text_ctrl.write('\n')
-
-                        self.text_ctrl.showPrompt()
-                        self.text_ctrl.write(cur_slice)
-                        self.text_ctrl.changeLine(completed or cur_slice)
-                    else:
-                        self.cur_state = 'COMPLETING'
-                        self.text_ctrl.writeCompletion(possibilities)
-                else:
-                    self.text_ctrl.changeLine(completed or cur_slice)
-                return
-            event.Skip()
-
-    #------------------------ Option Section ---------------------------------
-    def evtCheckOptionCompletion(self, event):
-        if event.IsChecked():
-            self.options['completion']['value']='STC'
-        else:
-            self.options['completion']['value']='IPYTHON'
-        self.text_ctrl.setCompletionMethod(self.options['completion']['value'])
-        self.updateOptionTracker('completion',
-                                 self.options['completion']['value'])
-        self.text_ctrl.SetFocus()
-
-    def evtCheckOptionBackgroundColor(self, event):
-        if event.IsChecked():
-            self.options['background_color']['value']='WHITE'
-        else:
-            self.options['background_color']['value']='BLACK'
-        self.text_ctrl.setBackgroundColor(self.options['background_color']['value'])
-        self.updateOptionTracker('background_color',
-                                 self.options['background_color']['value'])
-        self.text_ctrl.SetFocus()
-
-    def evtCheckOptionThreading(self, event):
-        if event.IsChecked():
-            self.options['threading']['value']='True'
-            self.IP.set_threading(True)
-            self.cout.write = self.text_ctrl.asyncWrite
-        else:
-            self.options['threading']['value']='False'
-            self.IP.set_threading(False)
-            self.cout.write = self.text_ctrl.write
-        self.updateOptionTracker('threading',
-                                 self.options['threading']['value'])
-        self.text_ctrl.SetFocus()
-
-    def getOptions(self):
-        return self.options
-
-    def reloadOptions(self,options):
-        self.options = options
-        for key in self.options.keys():
-            value = self.options[key]['value']
-            self.options[key]['checkbox'].SetValue(self.options[key][value])
-            self.options[key]['setfunc'](value)
-
-        if self.options['threading']['value']=='True':
-            self.IP.set_threading(True)
-            self.cout.write = self.text_ctrl.asyncWrite
-        else:
-            self.IP.set_threading(False)
-            self.cout.write = self.text_ctrl.write
-
-    #------------------------ Hook Section -----------------------------------
-    def updateOptionTracker(self,name,value):
-        '''
-        Default history tracker (does nothing)
-        '''
-        pass
-
-    def setOptionTrackerHook(self,func):
-        '''
-        Define a new history tracker
-        '''
-        self.updateOptionTracker = func
-
-    def updateHistoryTracker(self,command_line):
-        '''
-        Default history tracker (does nothing)
-        '''
-        pass
-
-    def setHistoryTrackerHook(self,func):
-        '''
-        Define a new history tracker
-        '''
-        self.updateHistoryTracker = func
-
-    def updateStatusTracker(self,status):
-        '''
-        Default status tracker (does nothing)
-        '''
-        pass
-
-    def setStatusTrackerHook(self,func):
-        '''
-        Define a new status tracker
-        '''
-        self.updateStatusTracker = func
-
-    def askExitHandler(self, event):
-        '''
-        Default exit handler
-        '''
-        self.text_ctrl.write('\nExit callback has not been set.')
-
-    def setAskExitHandler(self, func):
-        '''
-        Define an exit handler
-        '''
-        self.askExitHandler = func
-
-if __name__ == '__main__':
-    # Some simple code to test the shell widget.
-    class MainWindow(wx.Frame):
-        def __init__(self, parent, id, title):
-            wx.Frame.__init__(self, parent, id, title, size=(300,250))
-            self._sizer = wx.BoxSizer(wx.VERTICAL)
-            self.shell = IPShellWidget(self)
-            self._sizer.Add(self.shell, 1, wx.EXPAND)
-            self.SetSizer(self._sizer)
-            self.SetAutoLayout(1)
-            self.Show(True)
-
-    app = wx.PySimpleApp()
-    frame = MainWindow(None, wx.ID_ANY, 'Ipython')
-    frame.SetSize((780, 460))
-    shell = frame.shell
-
-    app.MainLoop()

IPython/deathrow/gui/wx/thread_ex.py

@@ -1,50 +0,0 b''
-"""
-Thread subclass that can deal with asynchronously function calls via
-raise_exc.
-"""
-
-import threading
-import inspect
-import ctypes
-
-
-def _async_raise(tid, exctype):
-    """raises the exception, performs cleanup if needed"""
-    if not inspect.isclass(exctype):
-        raise TypeError("Only types can be raised (not instances)")
-    res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype))
-    if res == 0:
-        raise ValueError("invalid thread id")
-    elif res != 1:
-        # """if it returns a number greater than one, you're in trouble,
-        # and you should call it again with exc=NULL to revert the effect"""
-        ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0)
-        raise SystemError("PyThreadState_SetAsyncExc failed")
-
-
-class ThreadEx(threading.Thread):
-    def _get_my_tid(self):
-        """determines this (self's) thread id"""
-        if not self.isAlive():
-            raise threading.ThreadError("the thread is not active")
-
-        # do we have it cached?
-        if hasattr(self, "_thread_id"):
-            return self._thread_id
-
-        # no, look for it in the _active dict
-        for tid, tobj in threading._active.items():
-            if tobj is self:
-                self._thread_id = tid
-                return tid
-
-        raise AssertionError("could not determine the thread's id")
-
-    def raise_exc(self, exctype):
-        """raises the given exception type in the context of this thread"""
-        _async_raise(self._get_my_tid(), exctype)
-
-    def kill(self):
-        """raises SystemExit in the context of the given thread, which should
-        cause the thread to exit silently (unless caught)"""
-        self.raise_exc(SystemExit)

IPython/deathrow/gui/wx/wxIPython.py

@@ -1,266 +0,0 b''
-#!/usr/bin/python
-# -*- coding: iso-8859-15 -*-
-
-import wx.aui
-import sys
-#used for about dialog
-from wx.lib.wordwrap import wordwrap
-
-#used for ipython GUI objects
-from IPython.gui.wx.ipython_view import IPShellWidget
-from IPython.gui.wx.ipython_history import IPythonHistoryPanel
-
-#used to invoke ipython1 wx implementation
-### FIXME ### temporary disabled due to interference with 'show_in_pager' hook
-is_sync_frontend_ok = False
-try:
-    from IPython.frontend.wx.ipythonx import IPythonXController
-except ImportError:
-    is_sync_frontend_ok = False
-
-#used to create options.conf file in user directory
-from IPython.core.ipapi import get
-
-__version__ = 0.91
-__author__  = "Laurent Dufrechou"
-__email__   = "laurent.dufrechou _at_ gmail.com"
-__license__ = "BSD"
-
-#-----------------------------------------
-# Creating one main frame for our
-# application with movables windows
-#-----------------------------------------
-class MyFrame(wx.Frame):
-    """Creating one main frame for our
-    application with movables windows"""
-    def __init__(self, parent=None, id=-1, title="WxIPython",
-                pos=wx.DefaultPosition,
-                size=(800, 600), style=wx.DEFAULT_FRAME_STYLE, sync_ok=False):
-        wx.Frame.__init__(self, parent, id, title, pos, size, style)
-        self._mgr = wx.aui.AuiManager()
-
-        # notify PyAUI which frame to use
-        self._mgr.SetManagedWindow(self)
-
-        #create differents panels and make them persistant
-        self.history_panel    = IPythonHistoryPanel(self)
-
-        self.history_panel.setOptionTrackerHook(self.optionSave)
-
-        self.ipython_panel    = IPShellWidget(self,background_color = "BLACK")
-        #self.ipython_panel    = IPShellWidget(self,background_color = "WHITE")
-        if(sync_ok):
-            self.ipython_panel2   = IPythonXController(self)
-        else:
-            self.ipython_panel2   = None
-        self.ipython_panel.setHistoryTrackerHook(self.history_panel.write)
-        self.ipython_panel.setStatusTrackerHook(self.updateStatus)
-        self.ipython_panel.setAskExitHandler(self.OnExitDlg)
-        self.ipython_panel.setOptionTrackerHook(self.optionSave)
-
-        #Create a notebook to display different IPython shell implementations
-        self.nb = wx.aui.AuiNotebook(self)
-
-        self.optionLoad()
-
-        self.statusbar = self.createStatus()
-        self.createMenu()
-
-        ########################################################################
-        ### add the panes to the manager
-        # main panels
-        self._mgr.AddPane(self.nb , wx.CENTER, "IPython Shells")
-        self.nb.AddPage(self.ipython_panel , "IPython0 Shell")
-        if(sync_ok):
-            self.nb.AddPage(self.ipython_panel2, "IPython1 Synchroneous Shell")
-
-        self._mgr.AddPane(self.history_panel , wx.RIGHT,  "IPython history")
-
-        # now we specify some panel characteristics
-        self._mgr.GetPane(self.ipython_panel).CaptionVisible(True);
-        self._mgr.GetPane(self.history_panel).CaptionVisible(True);
-        self._mgr.GetPane(self.history_panel).MinSize((200,400));
-
-        # tell the manager to "commit" all the changes just made
-        self._mgr.Update()
-
-        #global event handling
-        self.Bind(wx.EVT_CLOSE, self.OnClose)
-        self.Bind(wx.EVT_MENU,  self.OnClose,id=wx.ID_EXIT)
-        self.Bind(wx.EVT_MENU,  self.OnShowIPythonPanel,id=wx.ID_HIGHEST+1)
-        self.Bind(wx.EVT_MENU,  self.OnShowHistoryPanel,id=wx.ID_HIGHEST+2)
-        self.Bind(wx.EVT_MENU,  self.OnShowAbout, id=wx.ID_HIGHEST+3)
-        self.Bind(wx.EVT_MENU,  self.OnShowAllPanel,id=wx.ID_HIGHEST+6)
-
-        warn_text = 'Hello from IPython and wxPython.\n'
-        warn_text +='Please Note that this work is still EXPERIMENTAL\n'
-        warn_text +='It does NOT emulate currently all the IPython functions.\n'
-        warn_text +="\nIf you use MATPLOTLIB with show() you'll need to deactivate the THREADING option.\n"
-        if(not sync_ok):
-            warn_text +="\n->No twisted package detected, IPython1 example deactivated."
-
-        dlg = wx.MessageDialog(self,
-                               warn_text,
-                               'Warning Box',
-                               wx.OK | wx.ICON_INFORMATION
-                               )
-        dlg.ShowModal()
-        dlg.Destroy()
-
-    def optionSave(self, name, value):
-        ip = get()
-        path = ip.ipython_dir
-        opt = open(path + '/options.conf','w')
-
-        try:
-            options_ipython_panel = self.ipython_panel.getOptions()
-            options_history_panel = self.history_panel.getOptions()
-
-            for key in options_ipython_panel.keys():
-                opt.write(key + '=' + options_ipython_panel[key]['value']+'\n')
-            for key in options_history_panel.keys():
-                opt.write(key + '=' + options_history_panel[key]['value']+'\n')
-        finally:
-            opt.close()
-
-    def optionLoad(self):
-        try:
-            ip = get()
-            path = ip.ipython_dir
-            opt = open(path + '/options.conf','r')
-            lines = opt.readlines()
-            opt.close()
-
-            options_ipython_panel = self.ipython_panel.getOptions()
-            options_history_panel = self.history_panel.getOptions()
-
-            for line in lines:
-                key = line.split('=')[0]
-                value = line.split('=')[1].replace('\n','').replace('\r','')
-                if key in options_ipython_panel.keys():
-                    options_ipython_panel[key]['value'] = value
-                elif key in options_history_panel.keys():
-                    options_history_panel[key]['value'] = value
-                else:
-                    print >>sys.__stdout__,"Warning: key ",key,"not found in widget options. Check Options.conf"
-            self.ipython_panel.reloadOptions(options_ipython_panel)
-            self.history_panel.reloadOptions(options_history_panel)
-
-        except IOError:
-            print >>sys.__stdout__,"Could not open Options.conf, defaulting to default values."
-
-
-    def createMenu(self):
-        """local method used to create one menu bar"""
-
-        mb = wx.MenuBar()
-
-        file_menu = wx.Menu()
-        file_menu.Append(wx.ID_EXIT, "Exit")
-
-        view_menu = wx.Menu()
-        view_menu.Append(wx.ID_HIGHEST+1, "Show IPython Panel")
-        view_menu.Append(wx.ID_HIGHEST+2, "Show History Panel")
-        view_menu.AppendSeparator()
-        view_menu.Append(wx.ID_HIGHEST+6, "Show All")
-
-        about_menu = wx.Menu()
-        about_menu.Append(wx.ID_HIGHEST+3, "About")
-
-        mb.Append(file_menu, "File")
-        mb.Append(view_menu, "View")
-        mb.Append(about_menu, "About")
-        #mb.Append(options_menu, "Options")
-
-        self.SetMenuBar(mb)
-
-    def createStatus(self):
-        statusbar = self.CreateStatusBar(2, wx.ST_SIZEGRIP)
-        statusbar.SetStatusWidths([-2, -3])
-        statusbar.SetStatusText("Ready", 0)
-        statusbar.SetStatusText("WxIPython "+str(__version__), 1)
-        return statusbar
-
-    def updateStatus(self,text):
-        states = {'IDLE':'Idle',
-                  'DO_EXECUTE_LINE':'Send command',
-                  'WAIT_END_OF_EXECUTION':'Running command',
-                  'WAITING_USER_INPUT':'Waiting user input',
-                  'SHOW_DOC':'Showing doc',
-                  'SHOW_PROMPT':'Showing prompt'}
-        self.statusbar.SetStatusText(states[text], 0)
-
-    def OnClose(self, event):
-        """#event used to close program  """
-        # deinitialize the frame manager
-        self._mgr.UnInit()
-        self.Destroy()
-        event.Skip()
-
-    def OnExitDlg(self, event):
-        dlg = wx.MessageDialog(self, 'Are you sure you want to quit WxIPython',
-                                'WxIPython exit',
-                                wx.ICON_QUESTION |
-                                wx.YES_NO | wx.NO_DEFAULT
-                                )
-        if dlg.ShowModal() == wx.ID_YES:
-            dlg.Destroy()
-            self._mgr.UnInit()
-            self.Destroy()
-        dlg.Destroy()
-
-    #event to display IPython pannel
-    def OnShowIPythonPanel(self,event):
-        """ #event to display Boxpannel """
-        self._mgr.GetPane(self.ipython_panel).Show(True)
-        self._mgr.Update()
-    #event to display History pannel
-    def OnShowHistoryPanel(self,event):
-        self._mgr.GetPane(self.history_panel).Show(True)
-        self._mgr.Update()
-
-    def OnShowAllPanel(self,event):
-        """#event to display all Pannels"""
-        self._mgr.GetPane(self.ipython_panel).Show(True)
-        self._mgr.GetPane(self.history_panel).Show(True)
-        self._mgr.Update()
-
-    def OnShowAbout(self, event):
-        # First we create and fill the info object
-        info = wx.AboutDialogInfo()
-        info.Name = "WxIPython"
-        info.Version = str(__version__)
-        info.Copyright = "(C) 2007 Laurent Dufrechou"
-        info.Description = wordwrap(
-            "A Gui that embbed a multithreaded IPython Shell",
-            350, wx.ClientDC(self))
-        info.WebSite = ("http://ipython.scipy.org/", "IPython home page")
-        info.Developers = [ "Laurent Dufrechou" ]
-        licenseText="BSD License.\nAll rights reserved. This program and the accompanying materials are made available under the terms of the BSD which accompanies this distribution, and is available at http://www.opensource.org/licenses/bsd-license.php"
-        info.License = wordwrap(licenseText, 500, wx.ClientDC(self))
-
-        # Then we call wx.AboutBox giving it that info object
-        wx.AboutBox(info)
-
-#-----------------------------------------
-#Creating our application
-#-----------------------------------------
-class MyApp(wx.PySimpleApp):
-    """Creating our application"""
-    def __init__(self, sync_ok=False):
-        wx.PySimpleApp.__init__(self)
-
-        self.frame = MyFrame(sync_ok=sync_ok)
-        self.frame.Show()
-
-#-----------------------------------------
-#Main loop
-#-----------------------------------------
-def main():
-    app = MyApp(is_sync_frontend_ok)
-    app.SetTopWindow(app.frame)
-    app.MainLoop()
-
-#if launched as main program run this
-if __name__ == '__main__':
-    main()

IPython/deathrow/ibrowse.py

@@ -1,1767 +0,0 b''
-# -*- coding: iso-8859-1 -*-
-
-import curses, fcntl, signal, struct, tty, textwrap, inspect
-
-from IPython.core import ipapi
-
-import astyle, ipipe
-
-
-# Python 2.3 compatibility
-try:
-    set
-except NameError:
-    import sets
-    set = sets.Set
-
-# Python 2.3 compatibility
-try:
-    sorted
-except NameError:
-    from ipipe import sorted
-
-
-class UnassignedKeyError(Exception):
-    """
-    Exception that is used for reporting unassigned keys.
-    """
-
-
-class UnknownCommandError(Exception):
-    """
-    Exception that is used for reporting unknown commands (this should never
-    happen).
-    """
-
-
-class CommandError(Exception):
-    """
-    Exception that is used for reporting that a command can't be executed.
-    """
-
-
-class Keymap(dict):
-    """
-    Stores mapping of keys to commands.
-    """
-    def __init__(self):
-        self._keymap = {}
-
-    def __setitem__(self, key, command):
-        if isinstance(key, str):
-            for c in key:
-                dict.__setitem__(self, ord(c), command)
-        else:
-            dict.__setitem__(self, key, command)
-
-    def __getitem__(self, key):
-        if isinstance(key, str):
-            key = ord(key)
-        return dict.__getitem__(self, key)
-
-    def __detitem__(self, key):
-        if isinstance(key, str):
-            key = ord(key)
-        dict.__detitem__(self, key)
-
-    def register(self, command, *keys):
-        for key in keys:
-            self[key] = command
-
-    def get(self, key, default=None):
-        if isinstance(key, str):
-            key = ord(key)
-        return dict.get(self, key, default)
-
-    def findkey(self, command, default=ipipe.noitem):
-        for (key, commandcandidate) in self.iteritems():
-            if commandcandidate == command:
-                return key
-        if default is ipipe.noitem:
-            raise KeyError(command)
-        return default
-
-
-class _BrowserCachedItem(object):
-    # This is used internally by ``ibrowse`` to store a item together with its
-    # marked status.
-    __slots__ = ("item", "marked")
-
-    def __init__(self, item):
-        self.item = item
-        self.marked = False
-
-
-class _BrowserHelp(object):
-    style_header = astyle.Style.fromstr("yellow:black:bold")
-    # This is used internally by ``ibrowse`` for displaying the help screen.
-    def __init__(self, browser):
-        self.browser = browser
-
-    def __xrepr__(self, mode):
-        yield (-1, True)
-        if mode == "header" or mode == "footer":
-            yield (astyle.style_default, "ibrowse help screen")
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __iter__(self):
-        # Get reverse key mapping
-        allkeys = {}
-        for (key, cmd) in self.browser.keymap.iteritems():
-            allkeys.setdefault(cmd, []).append(key)
-
-        fields = ("key", "description")
-
-        commands = []
-        for name in dir(self.browser):
-            if name.startswith("cmd_"):
-                command = getattr(self.browser, name)
-                commands.append((inspect.getsourcelines(command)[-1], name[4:], command))
-        commands.sort()
-        commands = [(c[1], c[2]) for c in commands]
-        for (i, (name, command)) in enumerate(commands):
-            if i:
-                yield ipipe.Fields(fields, key="", description="")
-
-            description = command.__doc__
-            if description is None:
-                lines = []
-            else:
-                lines = [l.strip() for l in description.splitlines() if l.strip()]
-                description = "\n".join(lines)
-                lines = textwrap.wrap(description, 60)
-            keys = allkeys.get(name, [])
-
-            yield ipipe.Fields(fields, key="", description=astyle.Text((self.style_header, name)))
-            for i in xrange(max(len(keys), len(lines))):
-                try:
-                    key = self.browser.keylabel(keys[i])
-                except IndexError:
-                    key = ""
-                try:
-                    line = lines[i]
-                except IndexError:
-                    line = ""
-                yield ipipe.Fields(fields, key=key, description=line)
-
-
-class _BrowserLevel(object):
-    # This is used internally to store the state (iterator, fetch items,
-    # position of cursor and screen, etc.) of one browser level
-    # An ``ibrowse`` object keeps multiple ``_BrowserLevel`` objects in
-    # a stack.
-    def __init__(self, browser, input, mainsizey, *attrs):
-        self.browser = browser
-        self.input = input
-        self.header = [x for x in ipipe.xrepr(input, "header") if not isinstance(x[0], int)]
-        # iterator for the input
-        self.iterator = ipipe.xiter(input)
-
-        # is the iterator exhausted?
-        self.exhausted = False
-
-        # attributes to be display (autodetected if empty)
-        self.attrs = attrs
-
-        # fetched items (+ marked flag)
-        self.items = ipipe.deque()
-
-        # Number of marked objects
-        self.marked = 0
-
-        # Vertical cursor position
-        self.cury = 0
-
-        # Horizontal cursor position
-        self.curx = 0
-
-        # Index of first data column
-        self.datastartx = 0
-
-        # Index of first data line
-        self.datastarty = 0
-
-        # height of the data display area
-        self.mainsizey = mainsizey
-
-        # width of the data display area (changes when scrolling)
-        self.mainsizex = 0
-
-        # Size of row number (changes when scrolling)
-        self.numbersizex = 0
-
-        # Attributes to display (in this order)
-        self.displayattrs = []
-
-        # index and attribute under the cursor
-        self.displayattr = (None, ipipe.noitem)
-
-        # Maps attributes to column widths
-        self.colwidths = {}
-
-        # Set of hidden attributes
-        self.hiddenattrs = set()
-
-        # This takes care of all the caches etc.
-        self.moveto(0, 0, refresh=True)
-
-    def fetch(self, count):
-        # Try to fill ``self.items`` with at least ``count`` objects.
-        have = len(self.items)
-        while not self.exhausted and have < count:
-            try:
-                item = self.iterator.next()
-            except StopIteration:
-                self.exhausted = True
-                break
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception as exc:
-                have += 1
-                self.items.append(_BrowserCachedItem(exc))
-                self.exhausted = True
-                break
-            else:
-                have += 1
-                self.items.append(_BrowserCachedItem(item))
-
-    def calcdisplayattrs(self):
-        # Calculate which attributes are available from the objects that are
-        # currently visible on screen (and store it in ``self.displayattrs``)
-
-        attrs = set()
-        self.displayattrs = []
-        if self.attrs:
-            # If the browser object specifies a fixed list of attributes,
-            # simply use it (removing hidden attributes).
-            for attr in self.attrs:
-                attr = ipipe.upgradexattr(attr)
-                if attr not in attrs and attr not in self.hiddenattrs:
-                    self.displayattrs.append(attr)
-                    attrs.add(attr)
-        else:
-            endy = min(self.datastarty+self.mainsizey, len(self.items))
-            for i in xrange(self.datastarty, endy):
-                for attr in ipipe.xattrs(self.items[i].item, "default"):
-                    if attr not in attrs and attr not in self.hiddenattrs:
-                        self.displayattrs.append(attr)
-                        attrs.add(attr)
-
-    def getrow(self, i):
-        # Return a dictionary with the attributes for the object
-        # ``self.items[i]``. Attribute names are taken from
-        # ``self.displayattrs`` so ``calcdisplayattrs()`` must have been
-        # called before.
-        row = {}
-        item = self.items[i].item
-        for attr in self.displayattrs:
-            try:
-                value = attr.value(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception as exc:
-                value = exc
-            # only store attribute if it exists (or we got an exception)
-            if value is not ipipe.noitem:
-                # remember alignment, length and colored text
-                row[attr] = ipipe.xformat(value, "cell", self.browser.maxattrlength)
-        return row
-
-    def calcwidths(self):
-        # Recalculate the displayed fields and their widths.
-        # ``calcdisplayattrs()'' must have been called and the cache
-        # for attributes of the objects on screen (``self.displayrows``)
-        # must have been filled. This sets ``self.colwidths`` which maps
-        # attribute descriptors to widths.
-        self.colwidths = {}
-        for row in self.displayrows:
-            for attr in self.displayattrs:
-                try:
-                    length = row[attr][1]
-                except KeyError:
-                    length = 0
-                # always add attribute to colwidths, even if it doesn't exist
-                if attr not in self.colwidths:
-                    self.colwidths[attr] = len(attr.name())
-                newwidth = max(self.colwidths[attr], length)
-                self.colwidths[attr] = newwidth
-
-        # How many characters do we need to paint the largest item number?
-        self.numbersizex = len(str(self.datastarty+self.mainsizey-1))
-        # How must space have we got to display data?
-        self.mainsizex = self.browser.scrsizex-self.numbersizex-3
-        # width of all columns
-        self.datasizex = sum(self.colwidths.itervalues()) + len(self.colwidths)
-
-    def calcdisplayattr(self):
-        # Find out which attribute the cursor is on and store this
-        # information in ``self.displayattr``.
-        pos = 0
-        for (i, attr) in enumerate(self.displayattrs):
-            if pos+self.colwidths[attr] >= self.curx:
-                self.displayattr = (i, attr)
-                break
-            pos += self.colwidths[attr]+1
-        else:
-            self.displayattr = (None, ipipe.noitem)
-
-    def moveto(self, x, y, refresh=False):
-        # Move the cursor to the position ``(x,y)`` (in data coordinates,
-        # not in screen coordinates). If ``refresh`` is true, all cached
-        # values will be recalculated (e.g. because the list has been
-        # resorted, so screen positions etc. are no longer valid).
-        olddatastarty = self.datastarty
-        oldx = self.curx
-        oldy = self.cury
-        x = int(x+0.5)
-        y = int(y+0.5)
-        newx = x # remember where we wanted to move
-        newy = y # remember where we wanted to move
-
-        scrollbordery = min(self.browser.scrollbordery, self.mainsizey//2)
-        scrollborderx = min(self.browser.scrollborderx, self.mainsizex//2)
-
-        # Make sure that the cursor didn't leave the main area vertically
-        if y < 0:
-            y = 0
-        # try to get enough items to fill the screen
-        self.fetch(max(y+scrollbordery+1, self.mainsizey))
-        if y >= len(self.items):
-            y = max(0, len(self.items)-1)
-
-        # Make sure that the cursor stays on screen vertically
-        if y < self.datastarty+scrollbordery:
-            self.datastarty = max(0, y-scrollbordery)
-        elif y >= self.datastarty+self.mainsizey-scrollbordery:
-            self.datastarty = max(0, min(y-self.mainsizey+scrollbordery+1,
-                                         len(self.items)-self.mainsizey))
-
-        if refresh: # Do we need to refresh the complete display?
-            self.calcdisplayattrs()
-            endy = min(self.datastarty+self.mainsizey, len(self.items))
-            self.displayrows = map(self.getrow, xrange(self.datastarty, endy))
-            self.calcwidths()
-        # Did we scroll vertically => update displayrows
-        # and various other attributes
-        elif self.datastarty != olddatastarty:
-            # Recalculate which attributes we have to display
-            olddisplayattrs = self.displayattrs
-            self.calcdisplayattrs()
-            # If there are new attributes, recreate the cache
-            if self.displayattrs != olddisplayattrs:
-                endy = min(self.datastarty+self.mainsizey, len(self.items))
-                self.displayrows = map(self.getrow, xrange(self.datastarty, endy))
-            elif self.datastarty<olddatastarty: # we did scroll up
-                # drop rows from the end
-                del self.displayrows[self.datastarty-olddatastarty:]
-                # fetch new items
-                for i in xrange(min(olddatastarty, self.datastarty+self.mainsizey)-1,
-                                self.datastarty-1, -1):
-                    try:
-                        row = self.getrow(i)
-                    except IndexError:
-                        # we didn't have enough objects to fill the screen
-                        break
-                    self.displayrows.insert(0, row)
-            else: # we did scroll down
-                # drop rows from the start
-                del self.displayrows[:self.datastarty-olddatastarty]
-                # fetch new items
-                for i in xrange(max(olddatastarty+self.mainsizey, self.datastarty),
-                                self.datastarty+self.mainsizey):
-                    try:
-                        row = self.getrow(i)
-                    except IndexError:
-                        # we didn't have enough objects to fill the screen
-                        break
-                    self.displayrows.append(row)
-            self.calcwidths()
-
-        # Make sure that the cursor didn't leave the data area horizontally
-        if x < 0:
-            x = 0
-        elif x >= self.datasizex:
-            x = max(0, self.datasizex-1)
-
-        # Make sure that the cursor stays on screen horizontally
-        if x < self.datastartx+scrollborderx:
-            self.datastartx = max(0, x-scrollborderx)
-        elif x >= self.datastartx+self.mainsizex-scrollborderx:
-            self.datastartx = max(0, min(x-self.mainsizex+scrollborderx+1,
-                                         self.datasizex-self.mainsizex))
-
-        if x == oldx and y == oldy and (x != newx or y != newy): # couldn't move
-            self.browser.beep()
-        else:
-            self.curx = x
-            self.cury = y
-            self.calcdisplayattr()
-
-    def sort(self, key, reverse=False):
-        """
-        Sort the currently list of items using the key function ``key``. If
-        ``reverse`` is true the sort order is reversed.
-        """
-        curitem = self.items[self.cury] # Remember where the cursor is now
-
-        # Sort items
-        def realkey(item):
-            return key(item.item)
-        self.items = ipipe.deque(sorted(self.items, key=realkey, reverse=reverse))
-
-        # Find out where the object under the cursor went
-        cury = self.cury
-        for (i, item) in enumerate(self.items):
-            if item is curitem:
-                cury = i
-                break
-
-        self.moveto(self.curx, cury, refresh=True)
-
-    def refresh(self):
-        """
-        Restart iterating the input.
-        """
-        self.iterator = ipipe.xiter(self.input)
-        self.items.clear()
-        self.exhausted = False
-        self.datastartx = self.datastarty = 0
-        self.moveto(0, 0, refresh=True)
-
-    def refreshfind(self):
-        """
-        Restart iterating the input and go back to the same object as before
-        (if it can be found in the new iterator).
-        """
-        try:
-            oldobject = self.items[self.cury].item
-        except IndexError:
-            oldobject = ipipe.noitem
-        self.iterator = ipipe.xiter(self.input)
-        self.items.clear()
-        self.exhausted = False
-        while True:
-            self.fetch(len(self.items)+1)
-            if self.exhausted:
-                curses.beep()
-                self.datastartx = self.datastarty = 0
-                self.moveto(self.curx, 0, refresh=True)
-                break
-            if self.items[-1].item == oldobject:
-                self.datastartx = self.datastarty = 0
-                self.moveto(self.curx, len(self.items)-1, refresh=True)
-                break
-
-
-class _CommandInput(object):
-    keymap = Keymap()
-    keymap.register("left", curses.KEY_LEFT)
-    keymap.register("right", curses.KEY_RIGHT)
-    keymap.register("home", curses.KEY_HOME, "\x01") # Ctrl-A
-    keymap.register("end", curses.KEY_END, "\x05") # Ctrl-E
-    # FIXME: What's happening here?
-    keymap.register("backspace", curses.KEY_BACKSPACE, "\x08\x7f")
-    keymap.register("delete", curses.KEY_DC)
-    keymap.register("delend", 0x0b) # Ctrl-K
-    keymap.register("execute", "\r\n")
-    keymap.register("up", curses.KEY_UP)
-    keymap.register("down", curses.KEY_DOWN)
-    keymap.register("incsearchup", curses.KEY_PPAGE)
-    keymap.register("incsearchdown", curses.KEY_NPAGE)
-    keymap.register("exit", "\x18"), # Ctrl-X
-
-    def __init__(self, prompt):
-        self.prompt = prompt
-        self.history = []
-        self.maxhistory = 100
-        self.input = ""
-        self.curx = 0
-        self.cury = -1 # blank line
-
-    def start(self):
-        self.input = ""
-        self.curx = 0
-        self.cury = -1 # blank line
-
-    def handlekey(self, browser, key):
-        cmdname = self.keymap.get(key, None)
-        if cmdname is not None:
-            cmdfunc = getattr(self, "cmd_%s" % cmdname, None)
-            if cmdfunc is not None:
-                return cmdfunc(browser)
-            curses.beep()
-        elif key != -1:
-            try:
-                char = chr(key)
-            except ValueError:
-                curses.beep()
-            else:
-                return self.handlechar(browser, char)
-
-    def handlechar(self, browser, char):
-        self.input = self.input[:self.curx] + char + self.input[self.curx:]
-        self.curx += 1
-        return True
-
-    def dohistory(self):
-        self.history.insert(0, self.input)
-        del self.history[:-self.maxhistory]
-
-    def cmd_backspace(self, browser):
-        if self.curx:
-            self.input = self.input[:self.curx-1] + self.input[self.curx:]
-            self.curx -= 1
-            return True
-        else:
-            curses.beep()
-
-    def cmd_delete(self, browser):
-        if self.curx<len(self.input):
-            self.input = self.input[:self.curx] + self.input[self.curx+1:]
-            return True
-        else:
-            curses.beep()
-
-    def cmd_delend(self, browser):
-        if self.curx<len(self.input):
-            self.input = self.input[:self.curx]
-            return True
-
-    def cmd_left(self, browser):
-        if self.curx:
-            self.curx -= 1
-            return True
-        else:
-            curses.beep()
-
-    def cmd_right(self, browser):
-        if self.curx < len(self.input):
-            self.curx += 1
-            return True
-        else:
-            curses.beep()
-
-    def cmd_home(self, browser):
-        if self.curx:
-            self.curx = 0
-            return True
-        else:
-            curses.beep()
-
-    def cmd_end(self, browser):
-        if self.curx < len(self.input):
-            self.curx = len(self.input)
-            return True
-        else:
-            curses.beep()
-
-    def cmd_up(self, browser):
-        if self.cury < len(self.history)-1:
-            self.cury += 1
-            self.input = self.history[self.cury]
-            self.curx = len(self.input)
-            return True
-        else:
-            curses.beep()
-
-    def cmd_down(self, browser):
-        if self.cury >= 0:
-            self.cury -= 1
-            if self.cury>=0:
-                self.input = self.history[self.cury]
-            else:
-                self.input = ""
-            self.curx = len(self.input)
-            return True
-        else:
-            curses.beep()
-
-    def cmd_incsearchup(self, browser):
-        prefix = self.input[:self.curx]
-        cury = self.cury
-        while True:
-            cury += 1
-            if cury >= len(self.history):
-                break
-            if self.history[cury].startswith(prefix):
-                self.input = self.history[cury]
-                self.cury = cury
-                return True
-        curses.beep()
-
-    def cmd_incsearchdown(self, browser):
-        prefix = self.input[:self.curx]
-        cury = self.cury
-        while True:
-            cury -= 1
-            if cury <= 0:
-                break
-            if self.history[cury].startswith(prefix):
-                self.input = self.history[self.cury]
-                self.cury = cury
-                return True
-        curses.beep()
-
-    def cmd_exit(self, browser):
-        browser.mode = "default"
-        return True
-
-    def cmd_execute(self, browser):
-        raise NotImplementedError
-
-
-class _CommandGoto(_CommandInput):
-    def __init__(self):
-        _CommandInput.__init__(self, "goto object #")
-
-    def handlechar(self, browser, char):
-        # Only accept digits
-        if not "0" <= char <= "9":
-            curses.beep()
-        else:
-            return _CommandInput.handlechar(self, browser, char)
-
-    def cmd_execute(self, browser):
-        level = browser.levels[-1]
-        if self.input:
-            self.dohistory()
-            level.moveto(level.curx, int(self.input))
-        browser.mode = "default"
-        return True
-
-
-class _CommandFind(_CommandInput):
-    def __init__(self):
-        _CommandInput.__init__(self, "find expression")
-
-    def cmd_execute(self, browser):
-        level = browser.levels[-1]
-        if self.input:
-            self.dohistory()
-            while True:
-                cury = level.cury
-                level.moveto(level.curx, cury+1)
-                if cury == level.cury:
-                    curses.beep()
-                    break # hit end
-                item = level.items[level.cury].item
-                try:
-                    globals = ipipe.getglobals(None)
-                    if eval(self.input, globals, ipipe.AttrNamespace(item)):
-                        break # found something
-                except (KeyboardInterrupt, SystemExit):
-                    raise
-                except Exception as exc:
-                    browser.report(exc)
-                    curses.beep()
-                    break  # break on error
-        browser.mode = "default"
-        return True
-
-
-class _CommandFindBackwards(_CommandInput):
-    def __init__(self):
-        _CommandInput.__init__(self, "find backwards expression")
-
-    def cmd_execute(self, browser):
-        level = browser.levels[-1]
-        if self.input:
-            self.dohistory()
-            while level.cury:
-                level.moveto(level.curx, level.cury-1)
-                item = level.items[level.cury].item
-                try:
-                    globals = ipipe.getglobals(None)
-                    if eval(self.input, globals, ipipe.AttrNamespace(item)):
-                        break # found something
-                except (KeyboardInterrupt, SystemExit):
-                    raise
-                except Exception as exc:
-                    browser.report(exc)
-                    curses.beep()
-                    break # break on error
-            else:
-                curses.beep()
-        browser.mode = "default"
-        return True
-
-
-class ibrowse(ipipe.Display):
-    # Show this many lines from the previous screen when paging horizontally
-    pageoverlapx = 1
-
-    # Show this many lines from the previous screen when paging vertically
-    pageoverlapy = 1
-
-    # Start scrolling when the cursor is less than this number of columns
-    # away from the left or right screen edge
-    scrollborderx = 10
-
-    # Start scrolling when the cursor is less than this number of lines
-    # away from the top or bottom screen edge
-    scrollbordery = 5
-
-    # Accelerate by this factor when scrolling horizontally
-    acceleratex = 1.05
-
-    # Accelerate by this factor when scrolling vertically
-    acceleratey = 1.05
-
-    # The maximum horizontal scroll speed
-    # (as a factor of the screen width (i.e. 0.5 == half a screen width)
-    maxspeedx = 0.5
-
-    # The maximum vertical scroll speed
-    # (as a factor of the screen height (i.e. 0.5 == half a screen height)
-    maxspeedy = 0.5
-
-    # The maximum number of header lines for browser level
-    # if the nesting is deeper, only the innermost levels are displayed
-    maxheaders = 5
-
-    # The approximate maximum length of a column entry
-    maxattrlength = 200
-
-    # Styles for various parts of the GUI
-    style_objheadertext = astyle.Style.fromstr("white:black:bold|reverse")
-    style_objheadernumber = astyle.Style.fromstr("white:blue:bold|reverse")
-    style_objheaderobject = astyle.Style.fromstr("white:black:reverse")
-    style_colheader = astyle.Style.fromstr("blue:white:reverse")
-    style_colheaderhere = astyle.Style.fromstr("green:black:bold|reverse")
-    style_colheadersep = astyle.Style.fromstr("blue:black:reverse")
-    style_number = astyle.Style.fromstr("blue:white:reverse")
-    style_numberhere = astyle.Style.fromstr("green:black:bold|reverse")
-    style_sep = astyle.Style.fromstr("blue:black")
-    style_data = astyle.Style.fromstr("white:black")
-    style_datapad = astyle.Style.fromstr("blue:black:bold")
-    style_footer = astyle.Style.fromstr("black:white")
-    style_report = astyle.Style.fromstr("white:black")
-
-    # Column separator in header
-    headersepchar = "|"
-
-    # Character for padding data cell entries
-    datapadchar = "."
-
-    # Column separator in data area
-    datasepchar = "|"
-
-    # Character to use for "empty" cell (i.e. for non-existing attributes)
-    nodatachar = "-"
-
-    # Prompts for modes that require keyboard input
-    prompts = {
-        "goto": _CommandGoto(),
-        "find": _CommandFind(),
-        "findbackwards": _CommandFindBackwards()
-    }
-
-    # Maps curses key codes to "function" names
-    keymap = Keymap()
-    keymap.register("quit", "q")
-    keymap.register("up", curses.KEY_UP)
-    keymap.register("down", curses.KEY_DOWN)
-    keymap.register("pageup", curses.KEY_PPAGE)
-    keymap.register("pagedown", curses.KEY_NPAGE)
-    keymap.register("left", curses.KEY_LEFT)
-    keymap.register("right", curses.KEY_RIGHT)
-    keymap.register("home", curses.KEY_HOME, "\x01")
-    keymap.register("end", curses.KEY_END, "\x05")
-    keymap.register("prevattr", "<\x1b")
-    keymap.register("nextattr", ">\t")
-    keymap.register("pick", "p")
-    keymap.register("pickattr", "P")
-    keymap.register("pickallattrs", "C")
-    keymap.register("pickmarked", "m")
-    keymap.register("pickmarkedattr", "M")
-    keymap.register("pickinput", "i")
-    keymap.register("pickinputattr", "I")
-    keymap.register("hideattr", "h")
-    keymap.register("unhideattrs", "H")
-    keymap.register("help", "?")
-    keymap.register("enter", "\r\n")
-    keymap.register("enterattr", "E")
-    # FIXME: What's happening here?
-    keymap.register("leave", curses.KEY_BACKSPACE, "x\x08\x7f")
-    keymap.register("detail", "d")
-    keymap.register("detailattr", "D")
-    keymap.register("tooglemark", " ")
-    keymap.register("markrange", "%")
-    keymap.register("sortattrasc", "v")
-    keymap.register("sortattrdesc", "V")
-    keymap.register("goto", "g")
-    keymap.register("find", "f")
-    keymap.register("findbackwards", "b")
-    keymap.register("refresh", "r")
-    keymap.register("refreshfind", "R")
-
-    def __init__(self, input=None, *attrs):
-        """
-        Create a new browser. If ``attrs`` is not empty, it is the list
-        of attributes that will be displayed in the browser, otherwise
-        these will be determined by the objects on screen.
-        """
-        ipipe.Display.__init__(self, input)
-
-        self.attrs = attrs
-
-        # Stack of browser levels
-        self.levels = []
-        # how many colums to scroll (Changes when accelerating)
-        self.stepx = 1.
-
-        # how many rows to scroll (Changes when accelerating)
-        self.stepy = 1.
-
-        # Beep on the edges of the data area? (Will be set to ``False``
-        # once the cursor hits the edge of the screen, so we don't get
-        # multiple beeps).
-        self._dobeep = True
-
-        # Cache for registered ``curses`` colors and styles.
-        self._styles = {}
-        self._colors = {}
-        self._maxcolor = 1
-
-        # How many header lines do we want to paint (the numbers of levels
-        # we have, but with an upper bound)
-        self._headerlines = 1
-
-        # Index of first header line
-        self._firstheaderline = 0
-
-        # curses window
-        self.scr = None
-        # report in the footer line (error, executed command etc.)
-        self._report = None
-
-        # value to be returned to the caller (set by commands)
-        self.returnvalue = None
-
-        # The mode the browser is in
-        # e.g. normal browsing or entering an argument for a command
-        self.mode = "default"
-
-        # set by the SIGWINCH signal handler
-        self.resized = False
-
-    def nextstepx(self, step):
-        """
-        Accelerate horizontally.
-        """
-        return max(1., min(step*self.acceleratex,
-                           self.maxspeedx*self.levels[-1].mainsizex))
-
-    def nextstepy(self, step):
-        """
-        Accelerate vertically.
-        """
-        return max(1., min(step*self.acceleratey,
-                           self.maxspeedy*self.levels[-1].mainsizey))
-
-    def getstyle(self, style):
-        """
-        Register the ``style`` with ``curses`` or get it from the cache,
-        if it has been registered before.
-        """
-        try:
-            return self._styles[style.fg, style.bg, style.attrs]
-        except KeyError:
-            attrs = 0
-            for b in astyle.A2CURSES:
-                if style.attrs & b:
-                    attrs |= astyle.A2CURSES[b]
-            try:
-                color = self._colors[style.fg, style.bg]
-            except KeyError:
-                curses.init_pair(
-                    self._maxcolor,
-                    astyle.COLOR2CURSES[style.fg],
-                    astyle.COLOR2CURSES[style.bg]
-                )
-                color = curses.color_pair(self._maxcolor)
-                self._colors[style.fg, style.bg] = color
-                self._maxcolor += 1
-            c = color | attrs
-            self._styles[style.fg, style.bg, style.attrs] = c
-            return c
-
-    def addstr(self, y, x, begx, endx, text, style):
-        """
-        A version of ``curses.addstr()`` that can handle ``x`` coordinates
-        that are outside the screen.
-        """
-        text2 = text[max(0, begx-x):max(0, endx-x)]
-        if text2:
-            self.scr.addstr(y, max(x, begx), text2, self.getstyle(style))
-        return len(text)
-
-    def addchr(self, y, x, begx, endx, c, l, style):
-        x0 = max(x, begx)
-        x1 = min(x+l, endx)
-        if x1>x0:
-            self.scr.addstr(y, x0, c*(x1-x0), self.getstyle(style))
-        return l
-
-    def _calcheaderlines(self, levels):
-        # Calculate how many headerlines do we have to display, if we have
-        # ``levels`` browser levels
-        if levels is None:
-            levels = len(self.levels)
-        self._headerlines = min(self.maxheaders, levels)
-        self._firstheaderline = levels-self._headerlines
-
-    def getstylehere(self, style):
-        """
-        Return a style for displaying the original style ``style``
-        in the row the cursor is on.
-        """
-        return astyle.Style(style.fg, astyle.COLOR_BLUE, style.attrs | astyle.A_BOLD)
-
-    def report(self, msg):
-        """
-        Store the message ``msg`` for display below the footer line. This
-        will be displayed as soon as the screen is redrawn.
-        """
-        self._report = msg
-
-    def enter(self, item, *attrs):
-        """
-        Enter the object ``item``. If ``attrs`` is specified, it will be used
-        as a fixed list of attributes to display.
-        """
-        if self.levels and item is self.levels[-1].input:
-            curses.beep()
-            self.report(CommandError("Recursion on input object"))
-        else:
-            oldlevels = len(self.levels)
-            self._calcheaderlines(oldlevels+1)
-            try:
-                level = _BrowserLevel(
-                    self,
-                    item,
-                    self.scrsizey-1-self._headerlines-2,
-                    *attrs
-                )
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception as exc:
-                if not self.levels:
-                    raise
-                self._calcheaderlines(oldlevels)
-                curses.beep()
-                self.report(exc)
-            else:
-                self.levels.append(level)
-
-    def startkeyboardinput(self, mode):
-        """
-        Enter mode ``mode``, which requires keyboard input.
-        """
-        self.mode = mode
-        self.prompts[mode].start()
-
-    def keylabel(self, keycode):
-        """
-        Return a pretty name for the ``curses`` key ``keycode`` (used in the
-        help screen and in reports about unassigned keys).
-        """
-        if keycode <= 0xff:
-            specialsnames = {
-                ord("\n"): "RETURN",
-                ord(" "): "SPACE",
-                ord("\t"): "TAB",
-                ord("\x7f"): "DELETE",
-                ord("\x08"): "BACKSPACE",
-            }
-            if keycode in specialsnames:
-                return specialsnames[keycode]
-            elif 0x00 < keycode < 0x20:
-                return "CTRL-%s" % chr(keycode + 64)
-            return repr(chr(keycode))
-        for name in dir(curses):
-            if name.startswith("KEY_") and getattr(curses, name) == keycode:
-                return name
-        return str(keycode)
-
-    def beep(self, force=False):
-        if force or self._dobeep:
-            curses.beep()
-            # don't beep again (as long as the same key is pressed)
-            self._dobeep = False
-
-    def cmd_up(self):
-        """
-        Move the cursor to the previous row.
-        """
-        level = self.levels[-1]
-        self.report("up")
-        level.moveto(level.curx, level.cury-self.stepy)
-
-    def cmd_down(self):
-        """
-        Move the cursor to the next row.
-        """
-        level = self.levels[-1]
-        self.report("down")
-        level.moveto(level.curx, level.cury+self.stepy)
-
-    def cmd_pageup(self):
-        """
-        Move the cursor up one page.
-        """
-        level = self.levels[-1]
-        self.report("page up")
-        level.moveto(level.curx, level.cury-level.mainsizey+self.pageoverlapy)
-
-    def cmd_pagedown(self):
-        """
-        Move the cursor down one page.
-        """
-        level = self.levels[-1]
-        self.report("page down")
-        level.moveto(level.curx, level.cury+level.mainsizey-self.pageoverlapy)
-
-    def cmd_left(self):
-        """
-        Move the cursor left.
-        """
-        level = self.levels[-1]
-        self.report("left")
-        level.moveto(level.curx-self.stepx, level.cury)
-
-    def cmd_right(self):
-        """
-        Move the cursor right.
-        """
-        level = self.levels[-1]
-        self.report("right")
-        level.moveto(level.curx+self.stepx, level.cury)
-
-    def cmd_home(self):
-        """
-        Move the cursor to the first column.
-        """
-        level = self.levels[-1]
-        self.report("home")
-        level.moveto(0, level.cury)
-
-    def cmd_end(self):
-        """
-        Move the cursor to the last column.
-        """
-        level = self.levels[-1]
-        self.report("end")
-        level.moveto(level.datasizex+level.mainsizey-self.pageoverlapx, level.cury)
-
-    def cmd_prevattr(self):
-        """
-        Move the cursor one attribute column to the left.
-        """
-        level = self.levels[-1]
-        if level.displayattr[0] is None or level.displayattr[0] == 0:
-            self.beep()
-        else:
-            self.report("prevattr")
-            pos = 0
-            for (i, attrname) in enumerate(level.displayattrs):
-                if i == level.displayattr[0]-1:
-                    break
-                pos += level.colwidths[attrname] + 1
-            level.moveto(pos, level.cury)
-
-    def cmd_nextattr(self):
-        """
-        Move the cursor one attribute column to the right.
-        """
-        level = self.levels[-1]
-        if level.displayattr[0] is None or level.displayattr[0] == len(level.displayattrs)-1:
-            self.beep()
-        else:
-            self.report("nextattr")
-            pos = 0
-            for (i, attrname) in enumerate(level.displayattrs):
-                if i == level.displayattr[0]+1:
-                    break
-                pos += level.colwidths[attrname] + 1
-            level.moveto(pos, level.cury)
-
-    def cmd_pick(self):
-        """
-        'Pick' the object under the cursor (i.e. the row the cursor is on).
-        This leaves the browser and returns the picked object to the caller.
-        (In IPython this object will be available as the ``_`` variable.)
-        """
-        level = self.levels[-1]
-        self.returnvalue = level.items[level.cury].item
-        return True
-
-    def cmd_pickattr(self):
-        """
-        'Pick' the attribute under the cursor (i.e. the row/column the
-        cursor is on).
-        """
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no column under cursor"))
-            return
-        value = attr.value(level.items[level.cury].item)
-        if value is ipipe.noitem:
-            curses.beep()
-            self.report(AttributeError(attr.name()))
-        else:
-            self.returnvalue = value
-            return True
-
-    def cmd_pickallattrs(self):
-        """
-        Pick' the complete column under the cursor (i.e. the attribute under
-        the cursor) from all currently fetched objects. These attributes
-        will be returned as a list.
-        """
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no column under cursor"))
-            return
-        result = []
-        for cache in level.items:
-            value = attr.value(cache.item)
-            if value is not ipipe.noitem:
-                result.append(value)
-        self.returnvalue = result
-        return True
-
-    def cmd_pickmarked(self):
-        """
-        'Pick' marked objects. Marked objects will be returned as a list.
-        """
-        level = self.levels[-1]
-        self.returnvalue = [cache.item for cache in level.items if cache.marked]
-        return True
-
-    def cmd_pickmarkedattr(self):
-        """
-        'Pick' the attribute under the cursor from all marked objects
-        (This returns a list).
-        """
-
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no column under cursor"))
-            return
-        result = []
-        for cache in level.items:
-            if cache.marked:
-                value = attr.value(cache.item)
-                if value is not ipipe.noitem:
-                    result.append(value)
-        self.returnvalue = result
-        return True
-
-    def cmd_pickinput(self):
-        """
-        Use the object under the cursor (i.e. the row the cursor is on) as
-        the next input line. This leaves the browser and puts the picked object
-        in the input.
-        """
-        level = self.levels[-1]
-        value = level.items[level.cury].item
-        self.returnvalue = None
-        api = ipapi.get()
-        api.set_next_input(str(value))
-        return True
-
-    def cmd_pickinputattr(self):
-        """
-        Use the attribute under the cursor i.e. the row/column the cursor is on)
-        as the next input line. This leaves the browser and puts the picked
-        object in the input.
-        """
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no column under cursor"))
-            return
-        value = attr.value(level.items[level.cury].item)
-        if value is ipipe.noitem:
-            curses.beep()
-            self.report(AttributeError(attr.name()))
-        self.returnvalue = None
-        api = ipapi.get()
-        api.set_next_input(str(value))
-        return True
-
-    def cmd_markrange(self):
-        """
-        Mark all objects from the last marked object before the current cursor
-        position to the cursor position.
-        """
-        level = self.levels[-1]
-        self.report("markrange")
-        start = None
-        if level.items:
-            for i in xrange(level.cury, -1, -1):
-                if level.items[i].marked:
-                    start = i
-                    break
-        if start is None:
-            self.report(CommandError("no mark before cursor"))
-            curses.beep()
-        else:
-            for i in xrange(start, level.cury+1):
-                cache = level.items[i]
-                if not cache.marked:
-                    cache.marked = True
-                    level.marked += 1
-
-    def cmd_enter(self):
-        """
-        Enter the object under the cursor. (what this mean depends on the object
-        itself (i.e. how it implements iteration). This opens a new browser 'level'.
-        """
-        level = self.levels[-1]
-        try:
-            item = level.items[level.cury].item
-        except IndexError:
-            self.report(CommandError("No object"))
-            curses.beep()
-        else:
-            self.report("entering object...")
-            self.enter(item)
-
-    def cmd_leave(self):
-        """
-        Leave the current browser level and go back to the previous one.
-        """
-        self.report("leave")
-        if len(self.levels) > 1:
-            self._calcheaderlines(len(self.levels)-1)
-            self.levels.pop(-1)
-        else:
-            self.report(CommandError("This is the last level"))
-            curses.beep()
-
-    def cmd_enterattr(self):
-        """
-        Enter the attribute under the cursor.
-        """
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no column under cursor"))
-            return
-        try:
-            item = level.items[level.cury].item
-        except IndexError:
-            self.report(CommandError("No object"))
-            curses.beep()
-        else:
-            value = attr.value(item)
-            name = attr.name()
-            if value is ipipe.noitem:
-                self.report(AttributeError(name))
-            else:
-                self.report("entering object attribute %s..." % name)
-                self.enter(value)
-
-    def cmd_detail(self):
-        """
-        Show a detail view of the object under the cursor. This shows the
-        name, type, doc string and value of the object attributes (and it
-        might show more attributes than in the list view, depending on
-        the object).
-        """
-        level = self.levels[-1]
-        try:
-            item = level.items[level.cury].item
-        except IndexError:
-            self.report(CommandError("No object"))
-            curses.beep()
-        else:
-            self.report("entering detail view for object...")
-            attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
-            self.enter(attrs)
-
-    def cmd_detailattr(self):
-        """
-        Show a detail view of the attribute under the cursor.
-        """
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no attribute"))
-            return
-        try:
-            item = level.items[level.cury].item
-        except IndexError:
-            self.report(CommandError("No object"))
-            curses.beep()
-        else:
-            try:
-                item = attr.value(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception as exc:
-                self.report(exc)
-            else:
-                self.report("entering detail view for attribute %s..." % attr.name())
-                attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
-                self.enter(attrs)
-
-    def cmd_tooglemark(self):
-        """
-        Mark/unmark the object under the cursor. Marked objects have a '!'
-        after the row number).
-        """
-        level = self.levels[-1]
-        self.report("toggle mark")
-        try:
-            item = level.items[level.cury]
-        except IndexError: # no items?
-            pass
-        else:
-            if item.marked:
-                item.marked = False
-                level.marked -= 1
-            else:
-                item.marked = True
-                level.marked += 1
-
-    def cmd_sortattrasc(self):
-        """
-        Sort the objects (in ascending order) using the attribute under
-        the cursor as the sort key.
-        """
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no column under cursor"))
-            return
-        self.report("sort by %s (ascending)" % attr.name())
-        def key(item):
-            try:
-                return attr.value(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception:
-                return None
-        level.sort(key)
-
-    def cmd_sortattrdesc(self):
-        """
-        Sort the objects (in descending order) using the attribute under
-        the cursor as the sort key.
-        """
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no column under cursor"))
-            return
-        self.report("sort by %s (descending)" % attr.name())
-        def key(item):
-            try:
-                return attr.value(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception:
-                return None
-        level.sort(key, reverse=True)
-
-    def cmd_hideattr(self):
-        """
-        Hide the attribute under the cursor.
-        """
-        level = self.levels[-1]
-        if level.displayattr[0] is None:
-            self.beep()
-        else:
-            self.report("hideattr")
-            level.hiddenattrs.add(level.displayattr[1])
-            level.moveto(level.curx, level.cury, refresh=True)
-
-    def cmd_unhideattrs(self):
-        """
-        Make all attributes visible again.
-        """
-        level = self.levels[-1]
-        self.report("unhideattrs")
-        level.hiddenattrs.clear()
-        level.moveto(level.curx, level.cury, refresh=True)
-
-    def cmd_goto(self):
-        """
-        Jump to a row. The row number can be entered at the
-        bottom of the screen.
-        """
-        self.startkeyboardinput("goto")
-
-    def cmd_find(self):
-        """
-        Search forward for a row. The search condition can be entered at the
-        bottom of the screen.
-        """
-        self.startkeyboardinput("find")
-
-    def cmd_findbackwards(self):
-        """
-        Search backward for a row. The search condition can be entered at the
-        bottom of the screen.
-        """
-        self.startkeyboardinput("findbackwards")
-
-    def cmd_refresh(self):
-        """
-        Refreshes the display by restarting the iterator.
-        """
-        level = self.levels[-1]
-        self.report("refresh")
-        level.refresh()
-
-    def cmd_refreshfind(self):
-        """
-        Refreshes the display by restarting the iterator and goes back to the
-        same object the cursor was on before restarting (if this object can't be
-        found the cursor jumps back to the first object).
-        """
-        level = self.levels[-1]
-        self.report("refreshfind")
-        level.refreshfind()
-
-    def cmd_help(self):
-        """
-        Opens the help screen as a new browser level, describing keyboard
-        shortcuts.
-        """
-        for level in self.levels:
-            if isinstance(level.input, _BrowserHelp):
-                curses.beep()
-                self.report(CommandError("help already active"))
-                return
-
-        self.enter(_BrowserHelp(self))
-
-    def cmd_quit(self):
-        """
-        Quit the browser and return to the IPython prompt.
-        """
-        self.returnvalue = None
-        return True
-
-    def sigwinchhandler(self, signal, frame):
-        self.resized = True
-
-    def _dodisplay(self, scr):
-        """
-        This method is the workhorse of the browser. It handles screen
-        drawing and the keyboard.
-        """
-        self.scr = scr
-        curses.halfdelay(1)
-        footery = 2
-
-        keys = []
-        for cmd in ("quit", "help"):
-            key = self.keymap.findkey(cmd, None)
-            if key is not None:
-                keys.append("%s=%s" % (self.keylabel(key), cmd))
-        helpmsg = " | %s" % " ".join(keys)
-
-        scr.clear()
-        msg = "Fetching first batch of objects..."
-        (self.scrsizey, self.scrsizex) = scr.getmaxyx()
-        scr.addstr(self.scrsizey//2, (self.scrsizex-len(msg))//2, msg)
-        scr.refresh()
-
-        lastc = -1
-
-        self.levels = []
-        # enter the first level
-        self.enter(self.input, *self.attrs)
-
-        self._calcheaderlines(None)
-
-        while True:
-            level = self.levels[-1]
-            (self.scrsizey, self.scrsizex) = scr.getmaxyx()
-            level.mainsizey = self.scrsizey-1-self._headerlines-footery
-
-            # Paint object header
-            for i in xrange(self._firstheaderline, self._firstheaderline+self._headerlines):
-                lv = self.levels[i]
-                posx = 0
-                posy = i-self._firstheaderline
-                endx = self.scrsizex
-                if i: # not the first level
-                    msg = " (%d/%d" % (self.levels[i-1].cury, len(self.levels[i-1].items))
-                    if not self.levels[i-1].exhausted:
-                        msg += "+"
-                    msg += ") "
-                    endx -= len(msg)+1
-                posx += self.addstr(posy, posx, 0, endx, " ibrowse #%d: " % i, self.style_objheadertext)
-                for (style, text) in lv.header:
-                    posx += self.addstr(posy, posx, 0, endx, text, self.style_objheaderobject)
-                    if posx >= endx:
-                        break
-                if i:
-                    posx += self.addstr(posy, posx, 0, self.scrsizex, msg, self.style_objheadernumber)
-                posx += self.addchr(posy, posx, 0, self.scrsizex, " ", self.scrsizex-posx, self.style_objheadernumber)
-
-            if not level.items:
-                self.addchr(self._headerlines, 0, 0, self.scrsizex, " ", self.scrsizex, self.style_colheader)
-                self.addstr(self._headerlines+1, 0, 0, self.scrsizex, " <empty>", astyle.style_error)
-                scr.clrtobot()
-            else:
-                # Paint column headers
-                scr.move(self._headerlines, 0)
-                scr.addstr(" %*s " % (level.numbersizex, "#"), self.getstyle(self.style_colheader))
-                scr.addstr(self.headersepchar, self.getstyle(self.style_colheadersep))
-                begx = level.numbersizex+3
-                posx = begx-level.datastartx
-                for attr in level.displayattrs:
-                    attrname = attr.name()
-                    cwidth = level.colwidths[attr]
-                    header = attrname.ljust(cwidth)
-                    if attr is level.displayattr[1]:
-                        style = self.style_colheaderhere
-                    else:
-                        style = self.style_colheader
-                    posx += self.addstr(self._headerlines, posx, begx, self.scrsizex, header, style)
-                    posx += self.addstr(self._headerlines, posx, begx, self.scrsizex, self.headersepchar, self.style_colheadersep)
-                    if posx >= self.scrsizex:
-                        break
-                else:
-                    scr.addstr(" "*(self.scrsizex-posx), self.getstyle(self.style_colheader))
-
-                # Paint rows
-                posy = self._headerlines+1+level.datastarty
-                for i in xrange(level.datastarty, min(level.datastarty+level.mainsizey, len(level.items))):
-                    cache = level.items[i]
-                    if i == level.cury:
-                        style = self.style_numberhere
-                    else:
-                        style = self.style_number
-
-                    posy = self._headerlines+1+i-level.datastarty
-                    posx = begx-level.datastartx
-
-                    scr.move(posy, 0)
-                    scr.addstr(" %*d%s" % (level.numbersizex, i, " !"[cache.marked]), self.getstyle(style))
-                    scr.addstr(self.headersepchar, self.getstyle(self.style_sep))
-
-                    for attrname in level.displayattrs:
-                        cwidth = level.colwidths[attrname]
-                        try:
-                            (align, length, parts) = level.displayrows[i-level.datastarty][attrname]
-                        except KeyError:
-                            align = 2
-                            style = astyle.style_nodata
-                            if i == level.cury:
-                                style = self.getstylehere(style)
-                        padstyle = self.style_datapad
-                        sepstyle = self.style_sep
-                        if i == level.cury:
-                            padstyle = self.getstylehere(padstyle)
-                            sepstyle = self.getstylehere(sepstyle)
-                        if align == 2:
-                            posx += self.addchr(posy, posx, begx, self.scrsizex, self.nodatachar, cwidth, style)
-                        else:
-                            if align == 1:
-                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, cwidth-length, padstyle)
-                            elif align == 0:
-                                pad1 = (cwidth-length)//2
-                                pad2 = cwidth-length-len(pad1)
-                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, pad1, padstyle)
-                            for (style, text) in parts:
-                                if i == level.cury:
-                                    style = self.getstylehere(style)
-                                posx += self.addstr(posy, posx, begx, self.scrsizex, text, style)
-                                if posx >= self.scrsizex:
-                                    break
-                            if align == -1:
-                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, cwidth-length, padstyle)
-                            elif align == 0:
-                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, pad2, padstyle)
-                        posx += self.addstr(posy, posx, begx, self.scrsizex, self.datasepchar, sepstyle)
-                    else:
-                        scr.clrtoeol()
-
-                # Add blank row headers for the rest of the screen
-                for posy in xrange(posy+1, self.scrsizey-2):
-                    scr.addstr(posy, 0, " " * (level.numbersizex+2), self.getstyle(self.style_colheader))
-                    scr.clrtoeol()
-
-            posy = self.scrsizey-footery
-            # Display footer
-            scr.addstr(posy, 0, " "*self.scrsizex, self.getstyle(self.style_footer))
-
-            if level.exhausted:
-                flag = ""
-            else:
-                flag = "+"
-
-            endx = self.scrsizex-len(helpmsg)-1
-            scr.addstr(posy, endx, helpmsg, self.getstyle(self.style_footer))
-
-            posx = 0
-            msg = " %d%s objects (%d marked): " % (len(level.items), flag, level.marked)
-            posx += self.addstr(posy, posx, 0, endx, msg, self.style_footer)
-            try:
-                item = level.items[level.cury].item
-            except IndexError: # empty
-                pass
-            else:
-                for (nostyle, text) in ipipe.xrepr(item, "footer"):
-                    if not isinstance(nostyle, int):
-                        posx += self.addstr(posy, posx, 0, endx, text, self.style_footer)
-                        if posx >= endx:
-                            break
-
-                attrstyle = [(astyle.style_default, "no attribute")]
-                attr = level.displayattr[1]
-                if attr is not ipipe.noitem and not isinstance(attr, ipipe.SelfDescriptor):
-                    posx += self.addstr(posy, posx, 0, endx, " | ", self.style_footer)
-                    posx += self.addstr(posy, posx, 0, endx, attr.name(), self.style_footer)
-                    posx += self.addstr(posy, posx, 0, endx, ": ", self.style_footer)
-                    try:
-                        value = attr.value(item)
-                    except (SystemExit, KeyboardInterrupt):
-                        raise
-                    except Exception as exc:
-                        value = exc
-                    if value is not ipipe.noitem:
-                        attrstyle = ipipe.xrepr(value, "footer")
-                    for (nostyle, text) in attrstyle:
-                        if not isinstance(nostyle, int):
-                            posx += self.addstr(posy, posx, 0, endx, text, self.style_footer)
-                            if posx >= endx:
-                                break
-
-            try:
-                # Display input prompt
-                if self.mode in self.prompts:
-                    history = self.prompts[self.mode]
-                    posx = 0
-                    posy = self.scrsizey-1
-                    posx += self.addstr(posy, posx, 0, endx, history.prompt, astyle.style_default)
-                    posx += self.addstr(posy, posx, 0, endx, " [", astyle.style_default)
-                    if history.cury==-1:
-                        text = "new"
-                    else:
-                        text = str(history.cury+1)
-                    posx += self.addstr(posy, posx, 0, endx, text, astyle.style_type_number)
-                    if history.history:
-                        posx += self.addstr(posy, posx, 0, endx, "/", astyle.style_default)
-                        posx += self.addstr(posy, posx, 0, endx, str(len(history.history)), astyle.style_type_number)
-                    posx += self.addstr(posy, posx, 0, endx, "]: ", astyle.style_default)
-                    inputstartx = posx
-                    posx += self.addstr(posy, posx, 0, endx, history.input, astyle.style_default)
-                # Display report
-                else:
-                    if self._report is not None:
-                        if isinstance(self._report, Exception):
-                            style = self.getstyle(astyle.style_error)
-                            if self._report.__class__.__module__ == "exceptions":
-                                msg = "%s: %s" % \
-                                      (self._report.__class__.__name__, self._report)
-                            else:
-                                msg = "%s.%s: %s" % \
-                                      (self._report.__class__.__module__,
-                                       self._report.__class__.__name__, self._report)
-                        else:
-                            style = self.getstyle(self.style_report)
-                            msg = self._report
-                        scr.addstr(self.scrsizey-1, 0, msg[:self.scrsizex], style)
-                        self._report = None
-                    else:
-                        scr.move(self.scrsizey-1, 0)
-            except curses.error:
-                # Protect against errors from writing to the last line
-                pass
-            scr.clrtoeol()
-
-            # Position cursor
-            if self.mode in self.prompts:
-                history = self.prompts[self.mode]
-                scr.move(self.scrsizey-1, inputstartx+history.curx)
-            else:
-                scr.move(
-                    1+self._headerlines+level.cury-level.datastarty,
-                    level.numbersizex+3+level.curx-level.datastartx
-                )
-            scr.refresh()
-
-            # Check keyboard
-            while True:
-                c = scr.getch()
-                if self.resized:
-                    size = fcntl.ioctl(0, tty.TIOCGWINSZ, "12345678")
-                    size = struct.unpack("4H", size)
-                    oldsize = scr.getmaxyx()
-                    scr.erase()
-                    curses.resize_term(size[0], size[1])
-                    newsize = scr.getmaxyx()
-                    scr.erase()
-                    for l in self.levels:
-                        l.mainsizey += newsize[0]-oldsize[0]
-                        l.moveto(l.curx, l.cury, refresh=True)
-                    scr.refresh()
-                    self.resized = False
-                    break # Redisplay
-                if self.mode in self.prompts:
-                    if self.prompts[self.mode].handlekey(self, c):
-                       break # Redisplay
-                else:
-                    # if no key is pressed slow down and beep again
-                    if c == -1:
-                        self.stepx = 1.
-                        self.stepy = 1.
-                        self._dobeep = True
-                    else:
-                        # if a different key was pressed slow down and beep too
-                        if c != lastc:
-                            lastc = c
-                            self.stepx = 1.
-                            self.stepy = 1.
-                            self._dobeep = True
-                        cmdname = self.keymap.get(c, None)
-                        if cmdname is None:
-                            self.report(
-                                UnassignedKeyError("Unassigned key %s" %
-                                                   self.keylabel(c)))
-                        else:
-                            cmdfunc = getattr(self, "cmd_%s" % cmdname, None)
-                            if cmdfunc is None:
-                                self.report(
-                                    UnknownCommandError("Unknown command %r" %
-                                                        (cmdname,)))
-                            elif cmdfunc():
-                                returnvalue = self.returnvalue
-                                self.returnvalue = None
-                                return returnvalue
-                        self.stepx = self.nextstepx(self.stepx)
-                        self.stepy = self.nextstepy(self.stepy)
-                        curses.flushinp() # get rid of type ahead
-                        break # Redisplay
-        self.scr = None
-
-    def display(self):
-        if hasattr(curses, "resize_term") and hasattr(signal, 'SIGWINCH'):
-            oldhandler = signal.signal(signal.SIGWINCH, self.sigwinchhandler)
-            try:
-                return curses.wrapper(self._dodisplay)
-            finally:
-                signal.signal(signal.SIGWINCH, oldhandler)
-        else:
-            return curses.wrapper(self._dodisplay)

IPython/deathrow/igrid.py

@@ -1,1126 +0,0 b''
-# -*- coding: iso-8859-1 -*-
-
-import ipipe, os, webbrowser, urllib
-from IPython.core import ipapi
-import wx
-import wx.grid, wx.html
-
-try:
-    sorted
-except NameError:
-    from ipipe import sorted
-try:
-    set
-except:
-    from sets import Set as set
-
-
-__all__ = ["igrid"]
-
-
-help = """
-<?xml version='1.0' encoding='iso-8859-1'?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
-<link rel="stylesheet" href="igrid_help.css" type="text/css" />
-<title>igrid help</title>
-</head>
-<body>
-<h1>igrid help</h1>
-
-
-<h2>Commands</h2>
-
-
-<h3>pick (P)</h3>
-<p>Pick the whole row (object is available as "_")</p>
-
-<h3>pickattr (Shift-P)</h3>
-<p>Pick the attribute under the cursor</p>
-
-<h3>pickallattrs (Shift-C)</h3>
-<p>Pick the complete column under the cursor (i.e. the attribute under the
-cursor) from all currently fetched objects. These attributes will be returned
-as a list.</p>
-
-<h3>pickinput (I)</h3>
-<p>Pick the current row as next input line in IPython. Additionally the row is stored as "_"</p>
-
-<h3>pickinputattr (Shift-I)</h3>
-<p>Pick the attribute under the cursor as next input line in IPython. Additionally the row is stored as "_"</p>
-
-<h3>enter (E)</h3>
-<p>Enter the object under the cursor. (what this mean depends on the object
-itself, i.e. how it implements iteration). This opens a new browser 'level'.</p>
-
-<h3>enterattr (Shift-E)</h3>
-<p>Enter the attribute under the cursor.</p>
-
-<h3>detail (D)</h3>
-<p>Show a detail view of the object under the cursor. This shows the name,
-type, doc string and value of the object attributes (and it might show more
-attributes than in the list view, depending on the object).</p>
-
-<h3>detailattr (Shift-D)</h3>
-<p>Show a detail view of the attribute under the cursor.</p>
-
-<h3>pickrows (M)</h3>
-<p>Pick multiple selected rows (M)</p>
-
-<h3>pickrowsattr (CTRL-M)</h3>
-<p>From multiple selected rows pick the cells matching the attribute the cursor is in (CTRL-M)</p>
-
-<h3>find (CTRL-F)</h3>
-<p>Find text</p>
-
-<h3>find_expression (CTRL-Shift-F)</h3>
-<p>Find entries matching an expression</p>
-
-<h3>find_next (F3)</h3>
-<p>Find next occurrence</p>
-
-<h3>find_previous (Shift-F3)</h3>
-<p>Find previous occurrence</p>
-
-<h3>sortattrasc (V)</h3>
-<p>Sort the objects (in ascending order) using the attribute under the cursor as the sort key.</p>
-
-<h3>sortattrdesc (Shift-V)</h3>
-<p>Sort the objects (in descending order) using the attribute under the cursor as the sort key.</p>
-
-<h3>refresh_once (R, F5)</h3>
-<p>Refreshes the display by restarting the iterator</p>
-
-<h3>refresh_every_second</h3>
-<p>Refreshes the display by restarting the iterator every second until stopped by stop_refresh.</p>
-
-<h3>refresh_interval</h3>
-<p>Refreshes the display by restarting the iterator every X ms (X is a custom interval set by the user) until stopped by stop_refresh.</p>
-
-<h3>stop_refresh</h3>
-<p>Stops all refresh timers.</p>
-
-<h3>leave (Backspace, DEL, X)</h3>
-<p>Close current tab (and all the tabs to the right of the current one).</h3>
-
-<h3>quit (ESC,Q)</h3>
-<p>Quit igrid and return to the IPython prompt.</p>
-
-
-<h2>Navigation</h2>
-
-
-<h3>Jump to the last column of the current row (END, CTRL-E, CTRL-Right)</h3>
-
-<h3>Jump to the first column of the current row (HOME, CTRL-A, CTRL-Left)</h3>
-
-<h3>Move the cursor one column to the left (&lt;)</h3>
-
-<h3>Move the cursor one column to the right (&gt;)</h3>
-
-<h3>Jump to the first row in the current column (CTRL-Up)</h3>
-
-<h3>Jump to the last row in the current column (CTRL-Down)</h3>
-
-</body>
-</html>
-
-"""
-
-
-class IGridRenderer(wx.grid.PyGridCellRenderer):
-    """
-    This is a custom renderer for our IGridGrid
-    """
-    def __init__(self, table):
-        self.maxchars = 200
-        self.table = table
-        self.colormap = (
-            (  0,   0,   0),
-            (174,   0,   0),
-            (  0, 174,   0),
-            (174, 174,   0),
-            (  0,   0, 174),
-            (174,   0, 174),
-            (  0, 174, 174),
-            ( 64,  64,  64)
-        )
-
-        wx.grid.PyGridCellRenderer.__init__(self)
-
-    def _getvalue(self, row, col):
-        try:
-            value = self.table._displayattrs[col].value(self.table.items[row])
-            (align, width, text) = ipipe.xformat(value, "cell", self.maxchars)
-        except Exception as exc:
-            (align, width, text) = ipipe.xformat(exc, "cell", self.maxchars)
-        return (align, text)
-
-    def GetBestSize(self, grid, attr, dc, row, col):
-        text = grid.GetCellValue(row, col)
-        (align, text) = self._getvalue(row, col)
-        dc.SetFont(attr.GetFont())
-        (w, h) = dc.GetTextExtent(str(text))
-        return wx.Size(min(w+2, 600), h+2) # add border
-
-    def Draw(self, grid, attr, dc, rect, row, col, isSelected):
-        """
-        Takes care of drawing everything in the cell; aligns the text
-        """
-        text = grid.GetCellValue(row, col)
-        (align, text) = self._getvalue(row, col)
-        if isSelected:
-            bg = grid.GetSelectionBackground()
-        else:
-            bg = ["white", (240, 240, 240)][row%2]
-        dc.SetTextBackground(bg)
-        dc.SetBrush(wx.Brush(bg, wx.SOLID))
-        dc.SetPen(wx.TRANSPARENT_PEN)
-        dc.SetFont(attr.GetFont())
-        dc.DrawRectangleRect(rect)
-        dc.SetClippingRect(rect)
-        # Format the text
-        if align == -1: # left alignment
-            (width, height) = dc.GetTextExtent(str(text))
-            x = rect[0]+1
-            y = rect[1]+0.5*(rect[3]-height)
-
-            for (style, part) in text:
-                if isSelected:
-                    fg = grid.GetSelectionForeground()
-                else:
-                    fg = self.colormap[style.fg]
-                dc.SetTextForeground(fg)
-                (w, h) = dc.GetTextExtent(part)
-                dc.DrawText(part, x, y)
-                x += w
-        elif align == 0: # center alignment
-            (width, height) = dc.GetTextExtent(str(text))
-            x = rect[0]+0.5*(rect[2]-width)
-            y = rect[1]+0.5*(rect[3]-height)
-            for (style, part) in text:
-                if isSelected:
-                    fg = grid.GetSelectionForeground()
-                else:
-                    fg = self.colormap[style.fg]
-                dc.SetTextForeground(fg)
-                (w, h) = dc.GetTextExtent(part)
-                dc.DrawText(part, x, y)
-                x += w
-        else:  # right alignment
-            (width, height) = dc.GetTextExtent(str(text))
-            x = rect[0]+rect[2]-1
-            y = rect[1]+0.5*(rect[3]-height)
-            for (style, part) in reversed(text):
-                (w, h) = dc.GetTextExtent(part)
-                x -= w
-                if isSelected:
-                    fg = grid.GetSelectionForeground()
-                else:
-                    fg = self.colormap[style.fg]
-                dc.SetTextForeground(fg)
-                dc.DrawText(part, x, y)
-        dc.DestroyClippingRegion()
-
-    def Clone(self):
-        return IGridRenderer(self.table)
-
-
-class IGridTable(wx.grid.PyGridTableBase):
-    # The data table for the ``IGridGrid``. Some dirty tricks were used here:
-    # ``GetValue()`` does not get any values (or at least it does not return
-    # anything, accessing the values is done by the renderer)
-    # but rather tries to fetch the objects which were requested into the table.
-    # General behaviour is: Fetch the first X objects. If the user scrolls down
-    # to the last object another bunch of X objects is fetched (if possible)
-    def __init__(self, input, fontsize, *attrs):
-        wx.grid.PyGridTableBase.__init__(self)
-        self.input = input
-        self.iterator = ipipe.xiter(input)
-        self.items = []
-        self.attrs = [ipipe.upgradexattr(attr) for attr in attrs]
-        self._displayattrs = self.attrs[:]
-        self._displayattrset = set(self.attrs)
-        self.fontsize = fontsize
-        self._fetch(1)
-        self.timer = wx.Timer()
-        self.timer.Bind(wx.EVT_TIMER, self.refresh_content)
-
-    def GetAttr(self, *args):
-        attr = wx.grid.GridCellAttr()
-        attr.SetFont(wx.Font(self.fontsize, wx.TELETYPE, wx.NORMAL, wx.NORMAL))
-        return attr
-
-    def GetNumberRows(self):
-        return len(self.items)
-
-    def GetNumberCols(self):
-        return len(self._displayattrs)
-
-    def GetColLabelValue(self, col):
-        if col < len(self._displayattrs):
-            return self._displayattrs[col].name()
-        else:
-            return ""
-
-    def GetRowLabelValue(self, row):
-        return str(row)
-
-    def IsEmptyCell(self, row, col):
-        return False
-
-    def _append(self, item):
-        self.items.append(item)
-        # Nothing to do if the set of attributes has been fixed by the user
-        if not self.attrs:
-            for attr in ipipe.xattrs(item):
-                attr = ipipe.upgradexattr(attr)
-                if attr not in self._displayattrset:
-                    self._displayattrs.append(attr)
-                    self._displayattrset.add(attr)
-
-    def _fetch(self, count):
-        # Try to fill ``self.items`` with at least ``count`` objects.
-        have = len(self.items)
-        while self.iterator is not None and have < count:
-            try:
-                item = self.iterator.next()
-            except StopIteration:
-                self.iterator = None
-                break
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception as exc:
-                have += 1
-                self._append(exc)
-                self.iterator = None
-                break
-            else:
-                have += 1
-                self._append(item)
-
-    def GetValue(self, row, col):
-        # some kind of dummy-function: does not return anything but "";
-        # (The value isn't use anyway)
-        # its main task is to trigger the fetch of new objects
-        sizing_needed = False
-        had_cols = len(self._displayattrs)
-        had_rows = len(self.items)
-        if row == had_rows - 1 and self.iterator is not None:
-            self._fetch(row + 20)
-            sizing_needed = True
-        have_rows = len(self.items)
-        have_cols = len(self._displayattrs)
-        if have_rows > had_rows:
-            msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_ROWS_APPENDED, have_rows - had_rows)
-            self.GetView().ProcessTableMessage(msg)
-            sizing_needed = True
-        if row >= have_rows:
-            return ""
-        if have_cols != had_cols:
-            msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_COLS_APPENDED, have_cols - had_cols)
-            self.GetView().ProcessTableMessage(msg)
-            sizing_needed = True
-        if sizing_needed:
-            self.GetView().AutoSizeColumns(False)
-        return ""
-
-    def SetValue(self, row, col, value):
-        pass
-
-    def refresh_content(self, event):
-        msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_ROWS_DELETED, 0, self.GetNumberRows())
-        self.GetView().ProcessTableMessage(msg)
-        self.iterator = ipipe.xiter(self.input)
-        self.items = []
-        self.attrs = [] # _append will calculate new displayattrs
-        self._fetch(1) # fetch one...
-        if self.items:
-            msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_ROWS_APPENDED, 1)
-            self.GetView().ProcessTableMessage(msg)
-            self.GetValue(0, 0) # and trigger "fetch next 20"
-            item = self.items[0]
-            self.GetView().AutoSizeColumns(False)
-            panel = self.GetView().GetParent()
-            nb = panel.GetParent()
-            current = nb.GetSelection()
-            if nb.GetPage(current) == panel:
-                self.GetView().set_footer(item)
-
-class IGridGrid(wx.grid.Grid):
-    # The actual grid
-    # all methods for selecting/sorting/picking/... data are implemented here
-    def __init__(self, panel, input, *attrs):
-        wx.grid.Grid.__init__(self, panel)
-        fontsize = 9
-        self.input = input
-        self.table = IGridTable(self.input, fontsize, *attrs)
-        self.SetTable(self.table, True)
-        self.SetSelectionMode(wx.grid.Grid.wxGridSelectRows)
-        self.SetDefaultRenderer(IGridRenderer(self.table))
-        self.EnableEditing(False)
-        self.Bind(wx.EVT_KEY_DOWN, self.key_pressed)
-        self.Bind(wx.grid.EVT_GRID_CELL_LEFT_DCLICK, self.cell_doubleclicked)
-        self.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.cell_leftclicked)
-        self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_DCLICK, self.label_doubleclicked)
-        self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK, self.on_label_leftclick)
-        self.Bind(wx.grid.EVT_GRID_RANGE_SELECT, self._on_selected_range)
-        self.Bind(wx.grid.EVT_GRID_SELECT_CELL, self._on_selected_cell)
-        self.current_selection = set()
-        self.maxchars = 200
-
-    def on_label_leftclick(self, event):
-        event.Skip()
-
-    def error_output(self, text):
-        wx.Bell()
-        frame = self.GetParent().GetParent().GetParent()
-        frame.SetStatusText(str(text))
-
-    def _on_selected_range(self, event):
-        # Internal update to the selection tracking lists
-        if event.Selecting():
-            # adding to the list...
-            self.current_selection.update(xrange(event.GetTopRow(), event.GetBottomRow()+1))
-        else:
-            # removal from list
-            for index in xrange(event.GetTopRow(), event.GetBottomRow()+1):
-                self.current_selection.discard(index)
-        event.Skip()
-
-    def _on_selected_cell(self, event):
-        # Internal update to the selection tracking list
-        self.current_selection = set([event.GetRow()])
-        event.Skip()
-
-    def sort(self, key, reverse=False):
-        """
-        Sort the current list of items using the key function ``key``. If
-        ``reverse`` is true the sort order is reversed.
-        """
-        row = self.GetGridCursorRow()
-        col = self.GetGridCursorCol()
-        curitem = self.table.items[row] # Remember where the cursor is now
-        # Sort items
-        def realkey(item):
-            try:
-                return key(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception:
-                return None
-        try:
-            self.table.items = ipipe.deque(sorted(self.table.items, key=realkey, reverse=reverse))
-        except TypeError as exc:
-            self.error_output("Exception encountered: %s" % exc)
-            return
-        # Find out where the object under the cursor went
-        for (i, item) in enumerate(self.table.items):
-            if item is curitem:
-                self.SetGridCursor(i,col)
-                self.MakeCellVisible(i,col)
-                self.Refresh()
-
-    def sortattrasc(self):
-        """
-        Sort in ascending order; sorting criteria is the current attribute
-        """
-        col = self.GetGridCursorCol()
-        attr = self.table._displayattrs[col]
-        frame = self.GetParent().GetParent().GetParent()
-        if attr is ipipe.noitem:
-            self.error_output("no column under cursor")
-            return
-        frame.SetStatusText("sort by %s (ascending)" % attr.name())
-        def key(item):
-            try:
-                return attr.value(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception:
-                return None
-        self.sort(key)
-
-    def sortattrdesc(self):
-        """
-        Sort in descending order; sorting criteria is the current attribute
-        """
-        col = self.GetGridCursorCol()
-        attr = self.table._displayattrs[col]
-        frame = self.GetParent().GetParent().GetParent()
-        if attr is ipipe.noitem:
-            self.error_output("no column under cursor")
-            return
-        frame.SetStatusText("sort by %s (descending)" % attr.name())
-        def key(item):
-            try:
-                return attr.value(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception:
-                return None
-        self.sort(key, reverse=True)
-
-    def label_doubleclicked(self, event):
-        row = event.GetRow()
-        col = event.GetCol()
-        if col == -1:
-            self.enter(row)
-
-    def _getvalue(self, row, col):
-        """
-        Gets the text which is displayed at ``(row, col)``
-        """
-        try:
-            value = self.table._displayattrs[col].value(self.table.items[row])
-            (align, width, text) = ipipe.xformat(value, "cell", self.maxchars)
-        except IndexError:
-            raise IndexError
-        except Exception as exc:
-            (align, width, text) = ipipe.xformat(exc, "cell", self.maxchars)
-        return text
-
-    def searchexpression(self, searchexp, startrow=None, search_forward=True ):
-        """
-        Find by expression
-        """
-        frame = self.GetParent().GetParent().GetParent()
-        if searchexp:
-            if search_forward:
-                if not startrow:
-                    row = self.GetGridCursorRow()+1
-                else:
-                    row = startrow + 1
-                while True:
-                    try:
-                        foo = self.table.GetValue(row, 0)
-                        item = self.table.items[row]
-                        try:
-                            globals = ipipe.getglobals(None)
-                            if eval(searchexp, globals, ipipe.AttrNamespace(item)):
-                                self.SetGridCursor(row, 0) # found something
-                                self.MakeCellVisible(row, 0)
-                                break
-                        except (KeyboardInterrupt, SystemExit):
-                            raise
-                        except Exception as exc:
-                            frame.SetStatusText(str(exc))
-                            wx.Bell()
-                            break  # break on error
-                    except IndexError:
-                        return
-                    row += 1
-            else:
-                if not startrow:
-                    row = self.GetGridCursorRow() - 1
-                else:
-                    row = startrow - 1
-                while True:
-                    try:
-                        foo = self.table.GetValue(row, 0)
-                        item = self.table.items[row]
-                        try:
-                            globals = ipipe.getglobals(None)
-                            if eval(searchexp, globals, ipipe.AttrNamespace(item)):
-                                self.SetGridCursor(row, 0) # found something
-                                self.MakeCellVisible(row, 0)
-                                break
-                        except (KeyboardInterrupt, SystemExit):
-                            raise
-                        except Exception as exc:
-                            frame.SetStatusText(str(exc))
-                            wx.Bell()
-                            break  # break on error
-                    except IndexError:
-                        return
-                    row -= 1
-
-
-    def search(self, searchtext, startrow=None, startcol=None, search_forward=True):
-        """
-        search for ``searchtext``, starting in ``(startrow, startcol)``;
-        if ``search_forward`` is true the direction is "forward"
-        """
-        searchtext = searchtext.lower()
-        if search_forward:
-            if startrow is not None and startcol is not None:
-                row = startrow
-            else:
-                startcol = self.GetGridCursorCol() + 1
-                row = self.GetGridCursorRow()
-                if startcol >= self.GetNumberCols():
-                    startcol = 0
-                    row += 1
-            while True:
-                for col in xrange(startcol, self.table.GetNumberCols()):
-                    try:
-                        foo = self.table.GetValue(row, col)
-                        text = self._getvalue(row, col)
-                        if searchtext in text.string().lower():
-                            self.SetGridCursor(row, col)
-                            self.MakeCellVisible(row, col)
-                            return
-                    except IndexError:
-                        return
-                startcol = 0
-                row += 1
-        else:
-            if startrow is not None and startcol is not None:
-                row = startrow
-            else:
-                startcol = self.GetGridCursorCol() - 1
-                row = self.GetGridCursorRow()
-                if startcol < 0:
-                    startcol = self.GetNumberCols() - 1
-                    row -= 1
-            while True:
-                for col in xrange(startcol, -1, -1):
-                    try:
-                        foo = self.table.GetValue(row, col)
-                        text = self._getvalue(row, col)
-                        if searchtext in text.string().lower():
-                            self.SetGridCursor(row, col)
-                            self.MakeCellVisible(row, col)
-                            return
-                    except IndexError:
-                        return
-                startcol = self.table.GetNumberCols()-1
-                row -= 1
-
-    def key_pressed(self, event):
-        """
-        Maps pressed keys to functions
-        """
-        frame = self.GetParent().GetParent().GetParent()
-        frame.SetStatusText("")
-        sh = event.ShiftDown()
-        ctrl = event.ControlDown()
-
-        keycode = event.GetKeyCode()
-        if keycode == ord("P"):
-            row = self.GetGridCursorRow()
-            if sh:
-                col = self.GetGridCursorCol()
-                self.pickattr(row, col)
-            else:
-                self.pick(row)
-        elif keycode == ord("M"):
-            if ctrl:
-                col = self.GetGridCursorCol()
-                self.pickrowsattr(sorted(self.current_selection), col)
-            else:
-                self.pickrows(sorted(self.current_selection))
-        elif keycode in (wx.WXK_BACK, wx.WXK_DELETE, ord("X")) and not (ctrl or sh):
-            self.delete_current_notebook()
-        elif keycode in (ord("E"), ord("\r")):
-            row = self.GetGridCursorRow()
-            if sh:
-                col = self.GetGridCursorCol()
-                self.enterattr(row, col)
-            else:
-                self.enter(row)
-        elif keycode == ord("E") and ctrl:
-            row = self.GetGridCursorRow()
-            self.SetGridCursor(row, self.GetNumberCols()-1)
-        elif keycode == wx.WXK_HOME or (keycode == ord("A") and ctrl):
-            row = self.GetGridCursorRow()
-            self.SetGridCursor(row, 0)
-        elif keycode == ord("C") and sh:
-            col = self.GetGridCursorCol()
-            attr = self.table._displayattrs[col]
-            result = []
-            for i in xrange(self.GetNumberRows()):
-                result.append(self.table._displayattrs[col].value(self.table.items[i]))
-            self.quit(result)
-        elif keycode in (wx.WXK_ESCAPE, ord("Q")) and not (ctrl or sh):
-            self.quit()
-        elif keycode == ord("<"):
-            row = self.GetGridCursorRow()
-            col = self.GetGridCursorCol()
-            if not event.ShiftDown():
-                newcol = col - 1
-                if newcol >= 0:
-                    self.SetGridCursor(row, col - 1)
-            else:
-                newcol = col + 1
-                if newcol < self.GetNumberCols():
-                    self.SetGridCursor(row, col + 1)
-        elif keycode == ord("D"):
-            col = self.GetGridCursorCol()
-            row = self.GetGridCursorRow()
-            if not sh:
-                self.detail(row, col)
-            else:
-                self.detail_attr(row, col)
-        elif keycode == ord("F") and ctrl:
-            if sh:
-                frame.enter_searchexpression(event)
-            else:
-                frame.enter_searchtext(event)
-        elif keycode == wx.WXK_F3:
-            if sh:
-                frame.find_previous(event)
-            else:
-                frame.find_next(event)
-        elif keycode == ord("V"):
-            if sh:
-                self.sortattrdesc()
-            else:
-                self.sortattrasc()
-        elif keycode == wx.WXK_DOWN:
-            row = self.GetGridCursorRow()
-            try:
-                item = self.table.items[row+1]
-            except IndexError:
-                item = self.table.items[row]
-            self.set_footer(item)
-            event.Skip()
-        elif keycode == wx.WXK_UP:
-            row = self.GetGridCursorRow()
-            if row >= 1:
-                item = self.table.items[row-1]
-            else:
-                item = self.table.items[row]
-            self.set_footer(item)
-            event.Skip()
-        elif keycode == wx.WXK_RIGHT:
-            row = self.GetGridCursorRow()
-            item = self.table.items[row]
-            self.set_footer(item)
-            event.Skip()
-        elif keycode == wx.WXK_LEFT:
-            row = self.GetGridCursorRow()
-            item = self.table.items[row]
-            self.set_footer(item)
-            event.Skip()
-        elif keycode == ord("R") or keycode == wx.WXK_F5:
-            self.table.refresh_content(event)
-        elif keycode == ord("I"):
-            row = self.GetGridCursorRow()
-            if not sh:
-                self.pickinput(row)
-            else:
-                col = self.GetGridCursorCol()
-                self.pickinputattr(row, col)
-        else:
-            event.Skip()
-
-    def delete_current_notebook(self):
-        """
-        deletes the current notebook tab
-        """
-        panel = self.GetParent()
-        nb = panel.GetParent()
-        current = nb.GetSelection()
-        count = nb.GetPageCount()
-        if count > 1:
-            for i in xrange(count-1, current-1, -1):
-                nb.DeletePage(i)
-            nb.GetCurrentPage().grid.SetFocus()
-        else:
-            frame = nb.GetParent()
-            frame.SetStatusText("This is the last level!")
-
-    def _doenter(self, value, *attrs):
-        """
-        "enter" a special item resulting in a new notebook tab
-        """
-        panel = self.GetParent()
-        nb = panel.GetParent()
-        frame = nb.GetParent()
-        current = nb.GetSelection()
-        count = nb.GetPageCount()
-        try: # if we want to enter something non-iterable, e.g. a function
-            if current + 1 == count and value is not self.input: # we have an event in the last tab
-                frame._add_notebook(value, *attrs)
-            elif value != self.input: # we have to delete all tabs newer than [panel] first
-                for i in xrange(count-1, current, -1): # some tabs don't close if we don't close in *reverse* order
-                    nb.DeletePage(i)
-                frame._add_notebook(value)
-        except TypeError as exc:
-            if exc.__class__.__module__ == "exceptions":
-                msg = "%s: %s" % (exc.__class__.__name__, exc)
-            else:
-                msg = "%s.%s: %s" % (exc.__class__.__module__, exc.__class__.__name__, exc)
-            frame.SetStatusText(msg)
-
-    def enterattr(self, row, col):
-        try:
-            attr = self.table._displayattrs[col]
-            value = attr.value(self.table.items[row])
-        except Exception as exc:
-            self.error_output(str(exc))
-        else:
-            self._doenter(value)
-
-    def set_footer(self, item):
-        frame = self.GetParent().GetParent().GetParent()
-        frame.SetStatusText(" ".join([str(text) for (style, text) in ipipe.xformat(item, "footer", 20)[2]]), 0)
-
-    def enter(self, row):
-        try:
-            value = self.table.items[row]
-        except Exception as exc:
-            self.error_output(str(exc))
-        else:
-            self._doenter(value)
-
-    def detail(self, row, col):
-        """
-        shows a detail-view of the current cell
-        """
-        try:
-            attr = self.table._displayattrs[col]
-            item = self.table.items[row]
-        except Exception as exc:
-            self.error_output(str(exc))
-        else:
-            attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
-            self._doenter(attrs)
-
-    def detail_attr(self, row, col):
-        try:
-            attr = self.table._displayattrs[col]
-            item = attr.value(self.table.items[row])
-        except Exception as exc:
-            self.error_output(str(exc))
-        else:
-            attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
-            self._doenter(attrs)
-
-    def quit(self, result=None):
-        """
-        quit
-        """
-        frame = self.GetParent().GetParent().GetParent()
-        if frame.helpdialog:
-            frame.helpdialog.Destroy()
-        app = frame.parent
-        if app is not None:
-            app.result = result
-        frame.Close()
-        frame.Destroy()
-
-    def cell_doubleclicked(self, event):
-        self.enterattr(event.GetRow(), event.GetCol())
-        event.Skip()
-
-    def cell_leftclicked(self, event):
-        row = event.GetRow()
-        item = self.table.items[row]
-        self.set_footer(item)
-        event.Skip()
-
-    def pick(self, row):
-        """
-        pick a single row and return to the IPython prompt
-        """
-        try:
-            value = self.table.items[row]
-        except Exception as exc:
-            self.error_output(str(exc))
-        else:
-            self.quit(value)
-
-    def pickinput(self, row):
-        try:
-            value = self.table.items[row]
-        except Exception as exc:
-            self.error_output(str(exc))
-        else:
-            api = ipapi.get()
-            api.set_next_input(str(value))
-            self.quit(value)
-
-    def pickinputattr(self, row, col):
-        try:
-            attr = self.table._displayattrs[col]
-            value = attr.value(self.table.items[row])
-        except Exception as exc:
-            self.error_output(str(exc))
-        else:
-            api = ipapi.get()
-            api.set_next_input(str(value))
-            self.quit(value)
-
-    def pickrows(self, rows):
-        """
-        pick multiple rows and return to the IPython prompt
-        """
-        try:
-            value = [self.table.items[row] for row in rows]
-        except Exception as exc:
-            self.error_output(str(exc))
-        else:
-            self.quit(value)
-
-    def pickrowsattr(self, rows, col):
-        """"
-        pick one column from multiple rows
-        """
-        values = []
-        try:
-            attr = self.table._displayattrs[col]
-            for row in rows:
-                try:
-                    values.append(attr.value(self.table.items[row]))
-                except (SystemExit, KeyboardInterrupt):
-                    raise
-                except Exception:
-                    raise #pass
-        except Exception as exc:
-            self.error_output(str(exc))
-        else:
-            self.quit(values)
-
-    def pickattr(self, row, col):
-        try:
-            attr = self.table._displayattrs[col]
-            value = attr.value(self.table.items[row])
-        except Exception as exc:
-            self.error_output(str(exc))
-        else:
-            self.quit(value)
-
-
-class IGridPanel(wx.Panel):
-    # Each IGridPanel contains an IGridGrid
-    def __init__(self, parent, input, *attrs):
-        wx.Panel.__init__(self, parent, -1)
-        self.grid = IGridGrid(self, input, *attrs)
-        self.grid.FitInside()
-        sizer = wx.BoxSizer(wx.VERTICAL)
-        sizer.Add(self.grid, proportion=1, flag=wx.EXPAND | wx.ALL, border=10)
-        self.SetSizer(sizer)
-        sizer.Fit(self)
-        sizer.SetSizeHints(self)
-
-
-class IGridHTMLHelp(wx.Frame):
-    def __init__(self, parent, title, size):
-        wx.Frame.__init__(self, parent, -1, title, size=size)
-        html = wx.html.HtmlWindow(self)
-        if "gtk2" in wx.PlatformInfo:
-            html.SetStandardFonts()
-        html.SetPage(help)
-
-
-class IGridFrame(wx.Frame):
-    maxtitlelen = 30
-
-    def __init__(self, parent, input):
-        title =  " ".join([str(text) for (style, text) in ipipe.xformat(input, "header", 20)[2]])
-        wx.Frame.__init__(self, None, title=title, size=(640, 480))
-        self.menubar = wx.MenuBar()
-        self.menucounter = 100
-        self.m_help = wx.Menu()
-        self.m_search = wx.Menu()
-        self.m_sort = wx.Menu()
-        self.m_refresh = wx.Menu()
-        self.notebook = wx.Notebook(self, -1, style=0)
-        self.statusbar = self.CreateStatusBar(1, wx.ST_SIZEGRIP)
-        self.statusbar.SetFieldsCount(2)
-        self.SetStatusWidths([-1, 200])
-        self.parent = parent
-        self._add_notebook(input)
-        self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
-        self.makemenu(self.m_sort, "&Sort (asc)\tV", "Sort ascending", self.sortasc)
-        self.makemenu(self.m_sort, "Sort (&desc)\tShift-V", "Sort descending", self.sortdesc)
-        self.makemenu(self.m_help, "&Help\tF1", "Help", self.display_help)
-#        self.makemenu(self.m_help, "&Show help in browser", "Show help in browser", self.display_help_in_browser)
-        self.makemenu(self.m_search, "&Find text\tCTRL-F", "Find text", self.enter_searchtext)
-        self.makemenu(self.m_search, "Find by &expression\tCTRL-Shift-F", "Find by expression", self.enter_searchexpression)
-        self.makemenu(self.m_search, "Find &next\tF3", "Find next", self.find_next)
-        self.makemenu(self.m_search, "Find &previous\tShift-F3", "Find previous", self.find_previous)
-        self.makemenu(self.m_refresh, "&Refresh once \tF5", "Refresh once", self.refresh_once)
-        self.makemenu(self.m_refresh, "Refresh every &1s", "Refresh every second", self.refresh_every_second)
-        self.makemenu(self.m_refresh, "Refresh every &X seconds", "Refresh every X seconds", self.refresh_interval)
-        self.makemenu(self.m_refresh, "&Stop all refresh timers", "Stop refresh timers", self.stop_refresh)
-        self.menubar.Append(self.m_search, "&Find")
-        self.menubar.Append(self.m_sort, "&Sort")
-        self.menubar.Append(self.m_refresh, "&Refresh")
-        self.menubar.Append(self.m_help, "&Help")
-        self.SetMenuBar(self.menubar)
-        self.searchtext = ""
-        self.searchexpression = ""
-        self.helpdialog = None
-        self.refresh_interval = 1000
-        self.SetStatusText("Refreshing inactive", 1)
-
-    def refresh_once(self, event):
-        table = self.notebook.GetPage(self.notebook.GetSelection()).grid.table
-        table.refresh_content(event)
-
-    def refresh_interval(self, event):
-        table = self.notebook.GetPage(self.notebook.GetSelection()).grid.table
-        dlg = wx.TextEntryDialog(self, "Enter refresh interval (milliseconds):", "Refresh timer:", defaultValue=str(self.refresh_interval))
-        if dlg.ShowModal() == wx.ID_OK:
-            try:
-                milliseconds = int(dlg.GetValue())
-            except ValueError as exc:
-                self.SetStatusText(str(exc))
-            else:
-                table.timer.Start(milliseconds=milliseconds, oneShot=False)
-                self.SetStatusText("Refresh timer set to %s ms" % milliseconds)
-                self.SetStatusText("Refresh interval: %s ms" % milliseconds, 1)
-                self.refresh_interval = milliseconds
-        dlg.Destroy()
-
-    def stop_refresh(self, event):
-        for i in xrange(self.notebook.GetPageCount()):
-            nb = self.notebook.GetPage(i)
-            nb.grid.table.timer.Stop()
-            self.SetStatusText("Refreshing inactive", 1)
-
-    def refresh_every_second(self, event):
-        table = self.notebook.GetPage(self.notebook.GetSelection()).grid.table
-        table.timer.Start(milliseconds=1000, oneShot=False)
-        self.SetStatusText("Refresh interval: 1000 ms", 1)
-
-    def sortasc(self, event):
-        grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
-        grid.sortattrasc()
-
-    def sortdesc(self, event):
-        grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
-        grid.sortattrdesc()
-
-    def find_previous(self, event):
-        """
-        find previous occurrences
-        """
-        grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
-        if self.searchtext:
-            row = grid.GetGridCursorRow()
-            col = grid.GetGridCursorCol()
-            self.SetStatusText('Search mode: text; looking for %s' % self.searchtext)
-            if col-1 >= 0:
-                grid.search(self.searchtext, row, col-1, False)
-            else:
-                grid.search(self.searchtext, row-1, grid.table.GetNumberCols()-1, False)
-        elif self.searchexpression:
-            self.SetStatusText("Search mode: expression; looking for %s" % repr(self.searchexpression)[2:-1])
-            grid.searchexpression(searchexp=self.searchexpression, search_forward=False)
-        else:
-            self.SetStatusText("No search yet: please enter search-text or -expression")
-
-    def find_next(self, event):
-        """
-        find the next occurrence
-        """
-        grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
-        if self.searchtext != "":
-            row = grid.GetGridCursorRow()
-            col = grid.GetGridCursorCol()
-            self.SetStatusText('Search mode: text; looking for %s' % self.searchtext)
-            if col+1 < grid.table.GetNumberCols():
-                grid.search(self.searchtext, row, col+1)
-            else:
-                grid.search(self.searchtext, row+1, 0)
-        elif self.searchexpression != "":
-            self.SetStatusText('Search mode: expression; looking for %s' % repr(self.searchexpression)[2:-1])
-            grid.searchexpression(searchexp=self.searchexpression)
-        else:
-            self.SetStatusText("No search yet: please enter search-text or -expression")
-
-    def display_help(self, event):
-        """
-        Display a help dialog
-        """
-        if self.helpdialog:
-            self.helpdialog.Destroy()
-        self.helpdialog = IGridHTMLHelp(None, title="Help", size=wx.Size(600,400))
-        self.helpdialog.Show()
-
-    def display_help_in_browser(self, event):
-        """
-        Show the help-HTML in a browser (as a ``HtmlWindow`` does not understand
-        CSS this looks better)
-        """
-        filename = urllib.pathname2url(os.path.abspath(os.path.join(os.path.dirname(__file__), "igrid_help.html")))
-        if not filename.startswith("file"):
-            filename = "file:" + filename
-        webbrowser.open(filename, new=1, autoraise=True)
-
-    def enter_searchexpression(self, event):
-        dlg = wx.TextEntryDialog(self, "Find:", "Find matching expression:", defaultValue=self.searchexpression)
-        if dlg.ShowModal() == wx.ID_OK:
-            self.searchexpression = dlg.GetValue()
-            self.searchtext = ""
-            self.SetStatusText('Search mode: expression; looking for %s' % repr(self.searchexpression)[2:-1])
-            self.notebook.GetPage(self.notebook.GetSelection()).grid.searchexpression(self.searchexpression)
-        dlg.Destroy()
-
-    def makemenu(self, menu, label, help, cmd):
-        menu.Append(self.menucounter, label, help)
-        self.Bind(wx.EVT_MENU, cmd, id=self.menucounter)
-        self.menucounter += 1
-
-    def _add_notebook(self, input, *attrs):
-        # Adds another notebook which has the starting object ``input``
-        panel = IGridPanel(self.notebook, input, *attrs)
-        text = str(ipipe.xformat(input, "header", self.maxtitlelen)[2])
-        if len(text) >= self.maxtitlelen:
-            text = text[:self.maxtitlelen].rstrip(".") + "..."
-        self.notebook.AddPage(panel, text, True)
-        panel.grid.SetFocus()
-        self.Layout()
-
-    def OnCloseWindow(self, event):
-        self.Destroy()
-
-    def enter_searchtext(self, event):
-        # Displays a dialog asking for the searchtext
-        dlg = wx.TextEntryDialog(self, "Find:", "Find in list", defaultValue=self.searchtext)
-        if dlg.ShowModal() == wx.ID_OK:
-            self.searchtext = dlg.GetValue()
-            self.searchexpression = ""
-            self.SetStatusText('Search mode: text; looking for %s' % self.searchtext)
-            self.notebook.GetPage(self.notebook.GetSelection()).grid.search(self.searchtext)
-        dlg.Destroy()
-
-
-class App(wx.App):
-    def __init__(self, input):
-        self.input = input
-        self.result = None # Result to be returned to IPython. Set by quit().
-        wx.App.__init__(self)
-
-    def OnInit(self):
-        frame = IGridFrame(self, self.input)
-        frame.Show()
-        self.SetTopWindow(frame)
-        frame.Raise()
-        return True
-
-
-class igrid(ipipe.Display):
-    """
-    This is a wx-based display object that can be used instead of ``ibrowse``
-    (which is curses-based) or ``idump`` (which simply does a print).
-    """
-
-    if wx.VERSION < (2, 7):
-        def display(self):
-            try:
-                # Try to create a "standalone" frame. If this works we're probably
-                # running with -wthread.
-                # Note that this sets the parent of the frame to None, but we can't
-                # pass a result object back to the shell anyway.
-                frame = IGridFrame(None, self.input)
-                frame.Show()
-                frame.Raise()
-            except wx.PyNoAppError:
-                # There's no wx application yet => create one.
-                app = App(self.input)
-                app.MainLoop()
-                return app.result
-    else:
-        # With wx 2.7 it gets simpler.
-        def display(self):
-            app = App(self.input)
-            app.MainLoop()
-            return app.result
-

IPython/deathrow/igrid_help.css

@@ -1,45 +0,0 b''
-body
-{
-	background-color: #fff;
-	color: #000;
-	font-family: "Verdana", "Arial", "XHelvetica", "Helvetica", sans-serif;
-	padding: 20px 30px;
-	margin: 0px;
-	font-size: 11px;
-}
-h1
-{
-	font-family: "Trebuchet MS", sans-serif;
-	font-size: 24px;
-	margin: -20px -30px 4px -30px;
-	padding: 6px 30px;
-	font-weight: normal;
-	border-bottom: 1px solid #000;
-	letter-spacing: 1px;
-	background-color: #666;
-	color: #fff;
-}
-h2
-{
-	font-family: "Trebuchet MS", sans-serif;
-	font-size: 20px;
-	padding: 14px 0px 2px 0px;
-	margin: 0px;
-	font-weight: bold;
-	color: #333;
-}
-h3
-{
-	font-family: "Trebuchet MS", sans-serif;
-	font-size: 14px;
-	padding: 12px 0px 2px 0px;
-	margin: 0px;
-	font-weight: bold;
-	color: #333;
-}
-p
-{
-	line-height: 120%;
-	margin: 0px 0px 6px 0px;
-	padding: 0px;
-}

IPython/deathrow/igrid_help.html

@@ -1,86 +0,0 b''
-<?xml version='1.0' encoding='iso-8859-1'?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
-<link rel="stylesheet" href="igrid_help.css" type="text/css" />
-<title>igrid help</title>
-</head>
-<body>
-<h1>igrid help</h1>
-
-
-<h2>Commands</h2>
-
-
-<h3>pick (P)</h3>
-<p>Pick the whole row (object is available as "_")</p>
-
-<h3>pickattr (Shift-P)</h3>
-<p>Pick the attribute under the cursor</p>
-
-<h3>pickallattrs (Shift-C)</h3>
-<p>Pick' the complete column under the cursor (i.e. the attribute under the
-cursor) from all currently fetched objects. These attributes will be returned
-as a list.</p>
-
-<h3>enter (E)</h3>
-<p>Enter the object under the cursor. (what this mean depends on the object
-itself, i.e. how it implements iteration). This opens a new browser 'level'.</p>
-
-<h3>enterattr (Shift-E)</h3>
-<p>Enter the attribute under the cursor.</p>
-
-<h3>detail (D)</h3>
-<p>Show a detail view of the object under the cursor. This shows the name,
-type, doc string and value of the object attributes (and it might show more
-attributes than in the list view, depending on the object).</p>
-
-<h3>detailattr (Shift-D)</h3>
-<p>Show a detail view of the attribute under the cursor.</p>
-
-<h3>pickrows (M)</h3>
-<p>Pick multiple selected rows (M)</p>
-
-<h3>pickrowsattr (CTRL-M)</h3>
-<p>From multiple selected rows pick the cells matching the attribute the cursor is in (CTRL-M)</p>
-
-<h3>find (CTRL-F)</h3>
-<p>Find text</p>
-
-<h3>find_next (F3)</h3>
-<p>Find next occurrence of the searchtext</p>
-
-<h3>find_previous (Shift-F3)</h3>
-<p>Find previous occurrence of the searchtext </p>
-
-<h3>sortattrasc (V)</h3>
-<p>Sort the objects (in ascending order) using the attribute under the cursor as the sort key.</p>
-
-<h3>sortattrdesc (Shift-V)</h3>
-<p>Sort the objects (in descending order) using the attribute under the cursor as the sort key.</p>
-
-<h3>leave (Backspace, DEL, X)</h3>
-<p>Close current tab (and all the tabs to the right of the current one).</h3>
-
-<h3>quit (ESC,Q)</h3>
-<p>Quit igrid and return to the IPython prompt.</p>
-
-
-<h2>Navigation</h2>
-
-
-<h3>Jump to the last column of the current row (END, CTRL-E, CTRL-Right)</h3>
-
-<h3>Jump to the first column of the current row (HOME, CTRL-A, CTRL-Left)</h3>
-
-<h3>Move the cursor one column to the left (&lt;)</h3>
-
-<h3>Move the cursor one column to the right (&gt;)</h3>
-
-<h3>Jump to the first row in the current column (CTRL-Up)</h3>
-
-<h3>Jump to the last row in the current column (CTRL-Down)</h3>
-
-</body>
-</html>

IPython/deathrow/ipipe.py

@@ -1,2328 +0,0 b''
-# -*- coding: iso-8859-1 -*-
-
-"""
-``ipipe`` provides classes to be used in an interactive Python session. Doing a
-``from ipipe import *`` is the preferred way to do this. The name of all
-objects imported this way starts with ``i`` to minimize collisions.
-
-``ipipe`` supports "pipeline expressions", which is something resembling Unix
-pipes. An example is::
-
-    >>> ienv | isort("key.lower()")
-
-This gives a listing of all environment variables sorted by name.
-
-
-There are three types of objects in a pipeline expression:
-
-* ``Table``s: These objects produce items. Examples are ``ils`` (listing the
-  current directory, ``ienv`` (listing environment variables), ``ipwd`` (listing
-  user accounts) and ``igrp`` (listing user groups). A ``Table`` must be the
-  first object in a pipe expression.
-
-* ``Pipe``s: These objects sit in the middle of a pipe expression. They
-  transform the input in some way (e.g. filtering or sorting it). Examples are:
-  ``ifilter`` (which filters the input pipe), ``isort`` (which sorts the input
-  pipe) and ``ieval`` (which evaluates a function or expression for each object
-  in the input pipe).
-
-* ``Display``s: These objects can be put as the last object in a pipeline
-  expression. There are responsible for displaying the result of the pipeline
-  expression. If a pipeline expression doesn't end in a display object a default
-  display objects will be used. One example is ``ibrowse`` which is a ``curses``
-  based browser.
-
-
-Adding support for pipeline expressions to your own objects can be done through
-three extensions points (all of them optional):
-
-* An object that will be displayed as a row by a ``Display`` object should
-  implement the method ``__xattrs__(self, mode)`` method or register an
-  implementation of the generic function ``xattrs``. For more info see ``xattrs``.
-
-* When an object ``foo`` is displayed by a ``Display`` object, the generic
-  function ``xrepr`` is used.
-
-* Objects that can be iterated by ``Pipe``s must iterable. For special cases,
-  where iteration for display is different than the normal iteration a special
-  implementation can be registered with the generic function ``xiter``. This
-  makes it possible to use dictionaries and modules in pipeline expressions,
-  for example::
-
-      >>> import sys
-      >>> sys | ifilter("isinstance(value, int)") | idump
-      key        |value
-      api_version|      1012
-      dllhandle  | 503316480
-      hexversion |  33817328
-      maxint     |2147483647
-      maxunicode |     65535
-      >>> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
-      ...
-
-  Note: The expression strings passed to ``ifilter()`` and ``isort()`` can
-  refer to the object to be filtered or sorted via the variable ``_`` and to any
-  of the attributes of the object, i.e.::
-
-      >>> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
-
-  does the same as::
-
-      >>> sys.modules | ifilter("value is not None") | isort("key.lower()")
-
-  In addition to expression strings, it's possible to pass callables (taking
-  the object as an argument) to ``ifilter()``, ``isort()`` and ``ieval()``::
-
-      >>> sys | ifilter(lambda _:isinstance(_.value, int)) \
-      ...     | ieval(lambda _: (_.key, hex(_.value))) | idump
-      0          |1
-      api_version|0x3f4
-      dllhandle  |0x1e000000
-      hexversion |0x20402f0
-      maxint     |0x7fffffff
-      maxunicode |0xffff
-"""
-
-skip_doctest = True  # ignore top-level docstring as a doctest.
-
-import sys, os, os.path, stat, glob, new, csv, datetime, types
-import itertools, mimetypes, StringIO
-
-try: # Python 2.3 compatibility
-    import collections
-except ImportError:
-    deque = list
-else:
-    deque = collections.deque
-
-try: # Python 2.3 compatibility
-    set
-except NameError:
-    import sets
-    set = sets.Set
-
-try: # Python 2.3 compatibility
-    sorted
-except NameError:
-    def sorted(iterator, key=None, reverse=False):
-        items = list(iterator)
-        if key is not None:
-            items.sort(lambda i1, i2: cmp(key(i1), key(i2)))
-        else:
-            items.sort()
-        if reverse:
-            items.reverse()
-        return items
-
-try: # Python 2.4 compatibility
-    GeneratorExit
-except NameError:
-    GeneratorExit = SystemExit
-
-try:
-    import pwd
-except ImportError:
-    pwd = None
-
-try:
-    import grp
-except ImportError:
-    grp = None
-
-from IPython.external import simplegeneric
-from IPython.external import path
-
-try:
-    import IPython.utils.io
-    from IPython.utils import generics
-except ImportError:
-    Term = None
-    generics = None
-
-from IPython.core import ipapi
-
-
-__all__ = [
-    "ifile", "ils", "iglob", "iwalk", "ipwdentry", "ipwd", "igrpentry", "igrp",
-    "icsv", "ix", "ichain", "isort", "ifilter", "ieval", "ienum",
-    "ienv", "ihist", "ialias", "icap", "idump", "iless"
-]
-
-
-os.stat_float_times(True) # enable microseconds
-
-
-class AttrNamespace(object):
-    """
-    Helper class that is used for providing a namespace for evaluating
-    expressions containing attribute names of an object.
-    """
-    def __init__(self, wrapped):
-        self.wrapped = wrapped
-
-    def __getitem__(self, name):
-        if name == "_":
-            return self.wrapped
-        try:
-            return getattr(self.wrapped, name)
-        except AttributeError:
-            raise KeyError(name)
-
-# Python 2.3 compatibility
-# use eval workaround to find out which names are used in the
-# eval string and put them into the locals. This works for most
-# normal uses case, bizarre ones like accessing the locals()
-# will fail
-try:
-    eval("_", None, AttrNamespace(None))
-except TypeError:
-    real_eval = eval
-    def eval(codestring, _globals, _locals):
-        """
-        eval(source[, globals[, locals]]) -> value
-
-        Evaluate the source in the context of globals and locals.
-        The source may be a string representing a Python expression
-        or a code object as returned by compile().
-        The globals must be a dictionary and locals can be any mappping.
-
-        This function is a workaround for the shortcomings of
-        Python 2.3's eval.
-        """
-
-        if isinstance(codestring, basestring):
-            code = compile(codestring, "_eval", "eval")
-        else:
-            code = codestring
-        newlocals = {}
-        for name in code.co_names:
-            try:
-                newlocals[name] = _locals[name]
-            except KeyError:
-                pass
-        return real_eval(code, _globals, newlocals)
-
-
-noitem = object()
-
-
-def item(iterator, index, default=noitem):
-    """
-    Return the ``index``th item from the iterator ``iterator``.
-    ``index`` must be an integer (negative integers are relative to the
-    end (i.e. the last items produced by the iterator)).
-
-    If ``default`` is given, this will be the default value when
-    the iterator doesn't contain an item at this position. Otherwise an
-    ``IndexError`` will be raised.
-
-    Note that using this function will partially or totally exhaust the
-    iterator.
-    """
-    i = index
-    if i>=0:
-        for item in iterator:
-            if not i:
-                return item
-            i -= 1
-    else:
-        i = -index
-        cache = deque()
-        for item in iterator:
-            cache.append(item)
-            if len(cache)>i:
-                cache.popleft()
-        if len(cache)==i:
-            return cache.popleft()
-    if default is noitem:
-        raise IndexError(index)
-    else:
-        return default
-
-
-def getglobals(g):
-    """
-    Return the global namespace that is used for expression strings in
-    ``ifilter`` and others. This is ``g`` or (if ``g`` is ``None``) IPython's
-    user namespace.
-    """
-    if g is None:
-        if ipapi is not None:
-            api = ipapi.get()
-            if api is not None:
-                return api.user_ns
-        return globals()
-    return g
-
-
-class Descriptor(object):
-    """
-    A ``Descriptor`` object is used for describing the attributes of objects.
-    """
-    def __hash__(self):
-        return hash(self.__class__) ^ hash(self.key())
-
-    def __eq__(self, other):
-        return self.__class__ is other.__class__ and self.key() == other.key()
-
-    def __ne__(self, other):
-        return self.__class__ is not other.__class__ or self.key() != other.key()
-
-    def key(self):
-        pass
-
-    def name(self):
-        """
-        Return the name of this attribute for display by a ``Display`` object
-        (e.g. as a column title).
-        """
-        key = self.key()
-        if key is None:
-            return "_"
-        return str(key)
-
-    def attrtype(self, obj):
-        """
-        Return the type of this attribute (i.e. something like "attribute" or
-        "method").
-        """
-
-    def valuetype(self, obj):
-        """
-        Return the type of this attribute value of the object ``obj``.
-        """
-
-    def value(self, obj):
-        """
-        Return the value of this attribute of the object ``obj``.
-        """
-
-    def doc(self, obj):
-        """
-        Return the documentation for this attribute.
-        """
-
-    def shortdoc(self, obj):
-        """
-        Return a short documentation for this attribute (defaulting to the
-        first line).
-        """
-        doc = self.doc(obj)
-        if doc is not None:
-            doc = doc.strip().splitlines()[0].strip()
-        return doc
-
-    def iter(self, obj):
-        """
-        Return an iterator for this attribute of the object ``obj``.
-        """
-        return xiter(self.value(obj))
-
-
-class SelfDescriptor(Descriptor):
-    """
-    A ``SelfDescriptor`` describes the object itself.
-    """
-    def key(self):
-        return None
-
-    def attrtype(self, obj):
-        return "self"
-
-    def valuetype(self, obj):
-        return type(obj)
-
-    def value(self, obj):
-        return obj
-
-    def __repr__(self):
-        return "Self"
-
-selfdescriptor = SelfDescriptor() # there's no need for more than one
-
-
-class AttributeDescriptor(Descriptor):
-    """
-    An ``AttributeDescriptor`` describes a simple attribute of an object.
-    """
-    __slots__ = ("_name", "_doc")
-
-    def __init__(self, name, doc=None):
-        self._name = name
-        self._doc = doc
-
-    def key(self):
-        return self._name
-
-    def doc(self, obj):
-        return self._doc
-
-    def attrtype(self, obj):
-        return "attr"
-
-    def valuetype(self, obj):
-        return type(getattr(obj, self._name))
-
-    def value(self, obj):
-        return getattr(obj, self._name)
-
-    def __repr__(self):
-        if self._doc is None:
-            return "Attribute(%r)" % self._name
-        else:
-            return "Attribute(%r, %r)" % (self._name, self._doc)
-
-
-class IndexDescriptor(Descriptor):
-    """
-    An ``IndexDescriptor`` describes an "attribute" of an object that is fetched
-    via ``__getitem__``.
-    """
-    __slots__ = ("_index",)
-
-    def __init__(self, index):
-        self._index = index
-
-    def key(self):
-        return self._index
-
-    def attrtype(self, obj):
-        return "item"
-
-    def valuetype(self, obj):
-        return type(obj[self._index])
-
-    def value(self, obj):
-        return obj[self._index]
-
-    def __repr__(self):
-        return "Index(%r)" % self._index
-
-
-class MethodDescriptor(Descriptor):
-    """
-    A ``MethodDescriptor`` describes a method of an object that can be called
-    without argument. Note that this method shouldn't change the object.
-    """
-    __slots__ = ("_name", "_doc")
-
-    def __init__(self, name, doc=None):
-        self._name = name
-        self._doc = doc
-
-    def key(self):
-        return self._name
-
-    def doc(self, obj):
-        if self._doc is None:
-            return getattr(obj, self._name).__doc__
-        return self._doc
-
-    def attrtype(self, obj):
-        return "method"
-
-    def valuetype(self, obj):
-        return type(self.value(obj))
-
-    def value(self, obj):
-        return getattr(obj, self._name)()
-
-    def __repr__(self):
-        if self._doc is None:
-            return "Method(%r)" % self._name
-        else:
-            return "Method(%r, %r)" % (self._name, self._doc)
-
-
-class IterAttributeDescriptor(Descriptor):
-    """
-    An ``IterAttributeDescriptor`` works like an ``AttributeDescriptor`` but
-    doesn't return an attribute values (because this value might be e.g. a large
-    list).
-    """
-    __slots__ = ("_name", "_doc")
-
-    def __init__(self, name, doc=None):
-        self._name = name
-        self._doc = doc
-
-    def key(self):
-        return self._name
-
-    def doc(self, obj):
-        return self._doc
-
-    def attrtype(self, obj):
-        return "iter"
-
-    def valuetype(self, obj):
-        return noitem
-
-    def value(self, obj):
-        return noitem
-
-    def iter(self, obj):
-        return xiter(getattr(obj, self._name))
-
-    def __repr__(self):
-        if self._doc is None:
-            return "IterAttribute(%r)" % self._name
-        else:
-            return "IterAttribute(%r, %r)" % (self._name, self._doc)
-
-
-class IterMethodDescriptor(Descriptor):
-    """
-    An ``IterMethodDescriptor`` works like an ``MethodDescriptor`` but doesn't
-    return an attribute values (because this value might be e.g. a large list).
-    """
-    __slots__ = ("_name", "_doc")
-
-    def __init__(self, name, doc=None):
-        self._name = name
-        self._doc = doc
-
-    def key(self):
-        return self._name
-
-    def doc(self, obj):
-        if self._doc is None:
-            return getattr(obj, self._name).__doc__
-        return self._doc
-
-    def attrtype(self, obj):
-        return "itermethod"
-
-    def valuetype(self, obj):
-        return noitem
-
-    def value(self, obj):
-        return noitem
-
-    def iter(self, obj):
-        return xiter(getattr(obj, self._name)())
-
-    def __repr__(self):
-        if self._doc is None:
-            return "IterMethod(%r)" % self._name
-        else:
-            return "IterMethod(%r, %r)" % (self._name, self._doc)
-
-
-class FunctionDescriptor(Descriptor):
-    """
-    A ``FunctionDescriptor`` turns a function into a descriptor. The function
-    will be called with the object to get the type and value of the attribute.
-    """
-    __slots__ = ("_function", "_name", "_doc")
-
-    def __init__(self, function, name=None, doc=None):
-        self._function = function
-        self._name = name
-        self._doc = doc
-
-    def key(self):
-        return self._function
-
-    def name(self):
-        if self._name is not None:
-            return self._name
-        return getattr(self._function, "__xname__", self._function.__name__)
-
-    def doc(self, obj):
-        if self._doc is None:
-            return self._function.__doc__
-        return self._doc
-
-    def attrtype(self, obj):
-        return "function"
-
-    def valuetype(self, obj):
-        return type(self._function(obj))
-
-    def value(self, obj):
-        return self._function(obj)
-
-    def __repr__(self):
-        if self._doc is None:
-            return "Function(%r)" % self._name
-        else:
-            return "Function(%r, %r)" % (self._name, self._doc)
-
-
-class Table(object):
-    """
-    A ``Table`` is an object that produces items (just like a normal Python
-    iterator/generator does) and can be used as the first object in a pipeline
-    expression. The displayhook will open the default browser for such an object
-    (instead of simply printing the ``repr()`` result).
-    """
-
-    # We want to support ``foo`` and ``foo()`` in pipeline expression:
-    # So we implement the required operators (``|`` and ``+``) in the metaclass,
-    # instantiate the class and forward the operator to the instance
-    class __metaclass__(type):
-        def __iter__(self):
-            return iter(self())
-
-        def __or__(self, other):
-            return self() | other
-
-        def __add__(self, other):
-            return self() + other
-
-        def __radd__(self, other):
-            return other + self()
-
-        def __getitem__(self, index):
-            return self()[index]
-
-    def __getitem__(self, index):
-        return item(self, index)
-
-    def __contains__(self, item):
-        for haveitem in self:
-            if item == haveitem:
-                return True
-        return False
-
-    def __or__(self, other):
-        # autoinstantiate right hand side
-        if isinstance(other, type) and issubclass(other, (Table, Display)):
-            other = other()
-        # treat simple strings and functions as ``ieval`` instances
-        elif not isinstance(other, Display) and not isinstance(other, Table):
-            other = ieval(other)
-        # forward operations to the right hand side
-        return other.__ror__(self)
-
-    def __add__(self, other):
-        # autoinstantiate right hand side
-        if isinstance(other, type) and issubclass(other, Table):
-            other = other()
-        return ichain(self, other)
-
-    def __radd__(self, other):
-        # autoinstantiate left hand side
-        if isinstance(other, type) and issubclass(other, Table):
-            other = other()
-        return ichain(other, self)
-
-
-class Pipe(Table):
-    """
-    A ``Pipe`` is an object that can be used in a pipeline expression. It
-    processes the objects it gets from its input ``Table``/``Pipe``. Note that
-    a ``Pipe`` object can't be used as the first object in a pipeline
-    expression, as it doesn't produces items itself.
-    """
-    class __metaclass__(Table.__metaclass__):
-        def __ror__(self, input):
-            return input | self()
-
-    def __ror__(self, input):
-        # autoinstantiate left hand side
-        if isinstance(input, type) and issubclass(input, Table):
-            input = input()
-        self.input = input
-        return self
-
-
-def xrepr(item, mode="default"):
-    """
-    Generic function that adds color output and different display modes to ``repr``.
-
-    The result of an ``xrepr`` call is iterable and consists of ``(style, string)``
-    tuples. The ``style`` in this tuple must be a ``Style`` object from the
-    ``astring`` module. To reconfigure the output the first yielded tuple can be
-    a ``(aligment, full)`` tuple instead of a ``(style, string)`` tuple.
-    ``alignment``  can be -1 for left aligned, 0 for centered and 1 for right
-    aligned (the default is left alignment). ``full`` is a boolean that specifies
-    whether the complete output must be displayed or the ``Display`` object is
-    allowed to stop output after enough text has been produced (e.g. a syntax
-    highlighted text line would use ``True``, but for a large data structure
-    (i.e. a nested list, tuple or dictionary) ``False`` would be used).
-    The default is full output.
-
-    There are four different possible values for ``mode`` depending on where
-    the ``Display`` object will display ``item``:
-
-    ``"header"``
-        ``item`` will be displayed in a header line (this is used by ``ibrowse``).
-
-    ``"footer"``
-        ``item`` will be displayed in a footer line (this is used by ``ibrowse``).
-
-    ``"cell"``
-        ``item`` will be displayed in a table cell/list.
-
-    ``"default"``
-        default mode. If an ``xrepr`` implementation recursively outputs objects,
-        ``"default"`` must be passed in the recursive calls to ``xrepr``.
-
-    If no implementation is registered for ``item``, ``xrepr`` will try the
-    ``__xrepr__`` method on ``item``. If ``item`` doesn't have an ``__xrepr__``
-    method it falls back to ``repr``/``__repr__`` for all modes.
-    """
-    try:
-        func = item.__xrepr__
-    except AttributeError:
-        yield (astyle.style_default, repr(item))
-    else:
-        try:
-            for x in func(mode):
-                yield x
-        except (KeyboardInterrupt, SystemExit, GeneratorExit):
-            raise
-        except Exception:
-            yield (astyle.style_default, repr(item))
-xrepr = simplegeneric.generic(xrepr)
-
-
-def xrepr_none(self, mode="default"):
-    yield (astyle.style_type_none, repr(self))
-xrepr.when_object(None)(xrepr_none)
-
-
-def xrepr_noitem(self, mode="default"):
-    yield (2, True)
-    yield (astyle.style_nodata, "<?>")
-xrepr.when_object(noitem)(xrepr_noitem)
-
-
-def xrepr_bool(self, mode="default"):
-    yield (astyle.style_type_bool, repr(self))
-xrepr.when_type(bool)(xrepr_bool)
-
-
-def xrepr_str(self, mode="default"):
-    if mode == "cell":
-        yield (astyle.style_default, repr(self.expandtabs(tab))[1:-1])
-    else:
-        yield (astyle.style_default, repr(self))
-xrepr.when_type(str)(xrepr_str)
-
-
-def xrepr_unicode(self, mode="default"):
-    if mode == "cell":
-        yield (astyle.style_default, repr(self.expandtabs(tab))[2:-1])
-    else:
-        yield (astyle.style_default, repr(self))
-xrepr.when_type(unicode)(xrepr_unicode)
-
-
-def xrepr_number(self, mode="default"):
-    yield (1, True)
-    yield (astyle.style_type_number, repr(self))
-xrepr.when_type(int)(xrepr_number)
-xrepr.when_type(long)(xrepr_number)
-xrepr.when_type(float)(xrepr_number)
-
-
-def xrepr_complex(self, mode="default"):
-    yield (astyle.style_type_number, repr(self))
-xrepr.when_type(complex)(xrepr_number)
-
-
-def xrepr_datetime(self, mode="default"):
-    if mode == "cell":
-        # Don't use strftime() here, as this requires year >= 1900
-        yield (astyle.style_type_datetime,
-               "%04d-%02d-%02d %02d:%02d:%02d.%06d" % \
-                    (self.year, self.month, self.day,
-                     self.hour, self.minute, self.second,
-                     self.microsecond),
-                )
-    else:
-        yield (astyle.style_type_datetime, repr(self))
-xrepr.when_type(datetime.datetime)(xrepr_datetime)
-
-
-def xrepr_date(self, mode="default"):
-    if mode == "cell":
-        yield (astyle.style_type_datetime,
-               "%04d-%02d-%02d" % (self.year, self.month, self.day))
-    else:
-        yield (astyle.style_type_datetime, repr(self))
-xrepr.when_type(datetime.date)(xrepr_date)
-
-
-def xrepr_time(self, mode="default"):
-    if mode == "cell":
-        yield (astyle.style_type_datetime,
-                "%02d:%02d:%02d.%06d" % \
-                    (self.hour, self.minute, self.second, self.microsecond))
-    else:
-        yield (astyle.style_type_datetime, repr(self))
-xrepr.when_type(datetime.time)(xrepr_time)
-
-
-def xrepr_timedelta(self, mode="default"):
-    yield (astyle.style_type_datetime, repr(self))
-xrepr.when_type(datetime.timedelta)(xrepr_timedelta)
-
-
-def xrepr_type(self, mode="default"):
-    if self.__module__ == "__builtin__":
-        yield (astyle.style_type_type, self.__name__)
-    else:
-        yield (astyle.style_type_type, "%s.%s" % (self.__module__, self.__name__))
-xrepr.when_type(type)(xrepr_type)
-
-
-def xrepr_exception(self, mode="default"):
-    if self.__class__.__module__ == "exceptions":
-        classname = self.__class__.__name__
-    else:
-        classname = "%s.%s" % \
-            (self.__class__.__module__, self.__class__.__name__)
-    if mode == "header" or mode == "footer":
-        yield (astyle.style_error, "%s: %s" % (classname, self))
-    else:
-        yield (astyle.style_error, classname)
-xrepr.when_type(Exception)(xrepr_exception)
-
-
-def xrepr_listtuple(self, mode="default"):
-    if mode == "header" or mode == "footer":
-        if self.__class__.__module__ == "__builtin__":
-            classname = self.__class__.__name__
-        else:
-            classname = "%s.%s" % \
-                (self.__class__.__module__,self.__class__.__name__)
-        yield (astyle.style_default,
-               "<%s object with %d items at 0x%x>" % \
-                   (classname, len(self), id(self)))
-    else:
-        yield (-1, False)
-        if isinstance(self, list):
-            yield (astyle.style_default, "[")
-            end = "]"
-        else:
-            yield (astyle.style_default, "(")
-            end = ")"
-        for (i, subself) in enumerate(self):
-            if i:
-                yield (astyle.style_default, ", ")
-            for part in xrepr(subself, "default"):
-                yield part
-        yield (astyle.style_default, end)
-xrepr.when_type(list)(xrepr_listtuple)
-xrepr.when_type(tuple)(xrepr_listtuple)
-
-
-def xrepr_dict(self, mode="default"):
-    if mode == "header" or mode == "footer":
-        if self.__class__.__module__ == "__builtin__":
-            classname = self.__class__.__name__
-        else:
-            classname = "%s.%s" % \
-                (self.__class__.__module__,self.__class__.__name__)
-        yield (astyle.style_default,
-               "<%s object with %d items at 0x%x>" % \
-                (classname, len(self), id(self)))
-    else:
-        yield (-1, False)
-        if isinstance(self, dict):
-            yield (astyle.style_default, "{")
-            end = "}"
-        else:
-            yield (astyle.style_default, "dictproxy((")
-            end = "})"
-        for (i, (key, value)) in enumerate(self.iteritems()):
-            if i:
-                yield (astyle.style_default, ", ")
-            for part in xrepr(key, "default"):
-                yield part
-            yield (astyle.style_default, ": ")
-            for part in xrepr(value, "default"):
-                yield part
-        yield (astyle.style_default, end)
-xrepr.when_type(dict)(xrepr_dict)
-xrepr.when_type(types.DictProxyType)(xrepr_dict)
-
-
-def upgradexattr(attr):
-    """
-    Convert an attribute descriptor string to a real descriptor object.
-
-    If attr already is a descriptor object return it unmodified. A
-    ``SelfDescriptor`` will be returned if ``attr`` is ``None``. ``"foo"``
-    returns an ``AttributeDescriptor`` for the attribute named ``"foo"``.
-    ``"foo()"`` returns a ``MethodDescriptor`` for the method named ``"foo"``.
-    ``"-foo"`` will return an ``IterAttributeDescriptor`` for the attribute
-    named ``"foo"`` and ``"-foo()"`` will return an ``IterMethodDescriptor``
-    for the method named ``"foo"``. Furthermore integers will return the appropriate
-    ``IndexDescriptor`` and callables will return a ``FunctionDescriptor``.
-    """
-    if attr is None:
-        return selfdescriptor
-    elif isinstance(attr, Descriptor):
-        return attr
-    elif isinstance(attr, basestring):
-        if attr.endswith("()"):
-            if attr.startswith("-"):
-                return IterMethodDescriptor(attr[1:-2])
-            else:
-                return MethodDescriptor(attr[:-2])
-        else:
-            if attr.startswith("-"):
-                return IterAttributeDescriptor(attr[1:])
-            else:
-                return AttributeDescriptor(attr)
-    elif isinstance(attr, (int, long)):
-        return IndexDescriptor(attr)
-    elif callable(attr):
-        return FunctionDescriptor(attr)
-    else:
-        raise TypeError("can't handle descriptor %r" % attr)
-
-
-def xattrs(item, mode="default"):
-    """
-    Generic function that returns an iterable of attribute descriptors
-    to be used for displaying the attributes ob the object ``item`` in display
-    mode ``mode``.
-
-    There are two possible modes:
-
-    ``"detail"``
-        The ``Display`` object wants to display a detailed list of the object
-        attributes.
-
-    ``"default"``
-        The ``Display`` object wants to display the object in a list view.
-
-    If no implementation is registered for the object ``item`` ``xattrs`` falls
-    back to trying the ``__xattrs__`` method of the object. If this doesn't
-    exist either, ``dir(item)`` is used for ``"detail"`` mode and ``(None,)``
-    for ``"default"`` mode.
-
-    The implementation must yield attribute descriptors (see the class
-    ``Descriptor`` for more info). The ``__xattrs__`` method may also return
-    attribute descriptor strings (and ``None``) which will be converted to real
-    descriptors by ``upgradexattr()``.
-    """
-    try:
-        func = item.__xattrs__
-    except AttributeError:
-        if mode == "detail":
-            for attrname in dir(item):
-                yield AttributeDescriptor(attrname)
-        else:
-            yield selfdescriptor
-    else:
-        for attr in func(mode):
-            yield upgradexattr(attr)
-xattrs = simplegeneric.generic(xattrs)
-
-
-def xattrs_complex(self, mode="default"):
-    if mode == "detail":
-        return (AttributeDescriptor("real"), AttributeDescriptor("imag"))
-    return (selfdescriptor,)
-xattrs.when_type(complex)(xattrs_complex)
-
-
-def _isdict(item):
-    try:
-        itermeth = item.__class__.__iter__
-    except (AttributeError, TypeError):
-        return False
-    return itermeth is dict.__iter__ or itermeth is types.DictProxyType.__iter__
-
-
-def _isstr(item):
-    if not isinstance(item, basestring):
-        return False
-    try:
-        itermeth = item.__class__.__iter__
-    except AttributeError:
-        return True
-    return False # ``__iter__`` has been redefined
-
-
-def xiter(item):
-    """
-    Generic function that implements iteration for pipeline expression. If no
-    implementation is registered for ``item`` ``xiter`` falls back to ``iter``.
-    """
-    try:
-        func = item.__xiter__
-    except AttributeError:
-        if _isdict(item):
-            def items(item):
-                fields = ("key", "value")
-                for (key, value) in item.iteritems():
-                    yield Fields(fields, key=key, value=value)
-            return items(item)
-        elif isinstance(item, new.module):
-            def items(item):
-                fields = ("key", "value")
-                for key in sorted(item.__dict__):
-                    yield Fields(fields, key=key, value=getattr(item, key))
-            return items(item)
-        elif _isstr(item):
-            if not item:
-                raise ValueError("can't enter empty string")
-            lines = item.splitlines()
-            if len(lines) == 1:
-               def iterone(item):
-                   yield item
-               return iterone(item)
-            else:
-                return iter(lines)
-        return iter(item)
-    else:
-        return iter(func()) # iter() just to be safe
-xiter = simplegeneric.generic(xiter)
-
-
-class ichain(Pipe):
-    """
-    Chains multiple ``Table``s into one.
-    """
-
-    def __init__(self, *iters):
-        self.iters = iters
-
-    def __iter__(self):
-        return itertools.chain(*self.iters)
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer":
-            for (i, item) in enumerate(self.iters):
-                if i:
-                    yield (astyle.style_default, "+")
-                if isinstance(item, Pipe):
-                    yield (astyle.style_default, "(")
-                for part in xrepr(item, mode):
-                    yield part
-                if isinstance(item, Pipe):
-                    yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        args = ", ".join([repr(it) for it in self.iters])
-        return "%s.%s(%s)" % \
-            (self.__class__.__module__, self.__class__.__name__, args)
-
-
-class ifile(path.path):
-    """
-    file (or directory) object.
-    """
-
-    def getmode(self):
-        return self.stat().st_mode
-    mode = property(getmode, None, None, "Access mode")
-
-    def gettype(self):
-        data = [
-            (stat.S_ISREG, "file"),
-            (stat.S_ISDIR, "dir"),
-            (stat.S_ISCHR, "chardev"),
-            (stat.S_ISBLK, "blockdev"),
-            (stat.S_ISFIFO, "fifo"),
-            (stat.S_ISLNK, "symlink"),
-            (stat.S_ISSOCK,"socket"),
-        ]
-        lstat = self.lstat()
-        if lstat is not None:
-            types = set([text for (func, text) in data if func(lstat.st_mode)])
-        else:
-            types = set()
-        m = self.mode
-        types.update([text for (func, text) in data if func(m)])
-        return ", ".join(types)
-    type = property(gettype, None, None, "file type (file, directory, link, etc.)")
-
-    def getmodestr(self):
-        m = self.mode
-        data = [
-            (stat.S_IRUSR, "-r"),
-            (stat.S_IWUSR, "-w"),
-            (stat.S_IXUSR, "-x"),
-            (stat.S_IRGRP, "-r"),
-            (stat.S_IWGRP, "-w"),
-            (stat.S_IXGRP, "-x"),
-            (stat.S_IROTH, "-r"),
-            (stat.S_IWOTH, "-w"),
-            (stat.S_IXOTH, "-x"),
-        ]
-        return "".join([text[bool(m&bit)] for (bit, text) in data])
-
-    modestr = property(getmodestr, None, None, "Access mode as string")
-
-    def getblocks(self):
-        return self.stat().st_blocks
-    blocks = property(getblocks, None, None, "File size in blocks")
-
-    def getblksize(self):
-        return self.stat().st_blksize
-    blksize = property(getblksize, None, None, "Filesystem block size")
-
-    def getdev(self):
-        return self.stat().st_dev
-    dev = property(getdev)
-
-    def getnlink(self):
-        return self.stat().st_nlink
-    nlink = property(getnlink, None, None, "Number of links")
-
-    def getuid(self):
-        return self.stat().st_uid
-    uid = property(getuid, None, None, "User id of file owner")
-
-    def getgid(self):
-        return self.stat().st_gid
-    gid = property(getgid, None, None, "Group id of file owner")
-
-    def getowner(self):
-        stat = self.stat()
-        try:
-            return pwd.getpwuid(stat.st_uid).pw_name
-        except KeyError:
-            return stat.st_uid
-    owner = property(getowner, None, None, "Owner name (or id)")
-
-    def getgroup(self):
-        stat = self.stat()
-        try:
-            return grp.getgrgid(stat.st_gid).gr_name
-        except KeyError:
-            return stat.st_gid
-    group = property(getgroup, None, None, "Group name (or id)")
-
-    def getadate(self):
-        return datetime.datetime.utcfromtimestamp(self.atime)
-    adate = property(getadate, None, None, "Access date")
-
-    def getcdate(self):
-        return datetime.datetime.utcfromtimestamp(self.ctime)
-    cdate = property(getcdate, None, None, "Creation date")
-
-    def getmdate(self):
-        return datetime.datetime.utcfromtimestamp(self.mtime)
-    mdate = property(getmdate, None, None, "Modification date")
-
-    def mimetype(self):
-        """
-        Return MIME type guessed from the extension.
-        """
-        return mimetypes.guess_type(self.basename())[0]
-
-    def encoding(self):
-        """
-        Return guessed compression (like "compress" or "gzip").
-        """
-        return mimetypes.guess_type(self.basename())[1]
-
-    def __repr__(self):
-        return "ifile(%s)" % path._base.__repr__(self)
-
-    if sys.platform == "win32":
-        defaultattrs = (None, "type", "size", "modestr", "mdate")
-    else:
-        defaultattrs = (None, "type", "size", "modestr", "owner", "group", "mdate")
-
-    def __xattrs__(self, mode="default"):
-        if mode == "detail":
-            return (
-                "name",
-                "basename()",
-                "abspath()",
-                "realpath()",
-                "type",
-                "mode",
-                "modestr",
-                "stat()",
-                "lstat()",
-                "uid",
-                "gid",
-                "owner",
-                "group",
-                "dev",
-                "nlink",
-                "ctime",
-                "mtime",
-                "atime",
-                "cdate",
-                "mdate",
-                "adate",
-                "size",
-                "blocks",
-                "blksize",
-                "isdir()",
-                "islink()",
-                "mimetype()",
-                "encoding()",
-                "-listdir()",
-                "-dirs()",
-                "-files()",
-                "-walk()",
-                "-walkdirs()",
-                "-walkfiles()",
-            )
-        else:
-            return self.defaultattrs
-
-
-def xiter_ifile(self):
-    if self.isdir():
-        yield (self / os.pardir).abspath()
-        for child in sorted(self.listdir()):
-            yield child
-    else:
-        f = self.open("rb")
-        for line in f:
-            yield line
-        f.close()
-xiter.when_type(ifile)(xiter_ifile)
-
-
-# We need to implement ``xrepr`` for ``ifile`` as a generic function, because
-# otherwise ``xrepr_str`` would kick in.
-def xrepr_ifile(self, mode="default"):
-    try:
-        if self.isdir():
-            name = "idir"
-            style = astyle.style_dir
-        else:
-            name = "ifile"
-            style = astyle.style_file
-    except IOError:
-        name = "ifile"
-        style = astyle.style_default
-    if mode in ("cell", "header", "footer"):
-        abspath = repr(path._base(self.normpath()))
-        if abspath.startswith("u"):
-            abspath = abspath[2:-1]
-        else:
-            abspath = abspath[1:-1]
-        if mode == "cell":
-            yield (style, abspath)
-        else:
-            yield (style, "%s(%s)" % (name, abspath))
-    else:
-        yield (style, repr(self))
-xrepr.when_type(ifile)(xrepr_ifile)
-
-
-class ils(Table):
-    """
-    List the current (or a specified) directory.
-
-    Examples::
-
-        >>> ils
-        <class 'IPython.extensions.ipipe.ils'>
-        >>> ils("/usr/local/lib/python2.4")
-        IPython.extensions.ipipe.ils('/usr/local/lib/python2.4')
-        >>> ils("~")
-        IPython.extensions.ipipe.ils('/home/fperez')
-        # all-random
-    """
-    def __init__(self, base=os.curdir, dirs=True, files=True):
-        self.base = os.path.expanduser(base)
-        self.dirs = dirs
-        self.files = files
-
-    def __iter__(self):
-        base = ifile(self.base)
-        yield (base / os.pardir).abspath()
-        for child in sorted(base.listdir()):
-            if self.dirs:
-                if self.files:
-                    yield child
-                else:
-                    if child.isdir():
-                        yield child
-            elif self.files:
-                if not child.isdir():
-                    yield child
-
-    def __xrepr__(self, mode="default"):
-       return xrepr(ifile(self.base), mode)
-
-    def __repr__(self):
-        return "%s.%s(%r)" % \
-            (self.__class__.__module__, self.__class__.__name__, self.base)
-
-
-class iglob(Table):
-    """
-    List all files and directories matching a specified pattern.
-    (See ``glob.glob()`` for more info.).
-
-    Examples::
-
-        >>> iglob("*.py")
-        IPython.extensions.ipipe.iglob('*.py')
-    """
-    def __init__(self, glob):
-        self.glob = glob
-
-    def __iter__(self):
-        for name in glob.glob(self.glob):
-            yield ifile(name)
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer" or mode == "cell":
-            yield (astyle.style_default,
-                   "%s(%r)" % (self.__class__.__name__, self.glob))
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "%s.%s(%r)" % \
-            (self.__class__.__module__, self.__class__.__name__, self.glob)
-
-
-class iwalk(Table):
-    """
-    List all files and directories in a directory and it's subdirectory::
-
-        >>> iwalk
-        <class 'IPython.extensions.ipipe.iwalk'>
-        >>> iwalk("/usr/lib")
-        IPython.extensions.ipipe.iwalk('/usr/lib')
-        >>> iwalk("~")
-        IPython.extensions.ipipe.iwalk('/home/fperez')  # random
-        
-    """
-    def __init__(self, base=os.curdir, dirs=True, files=True):
-        self.base = os.path.expanduser(base)
-        self.dirs = dirs
-        self.files = files
-
-    def __iter__(self):
-        for (dirpath, dirnames, filenames) in os.walk(self.base):
-            if self.dirs:
-                for name in sorted(dirnames):
-                    yield ifile(os.path.join(dirpath, name))
-            if self.files:
-                for name in sorted(filenames):
-                    yield ifile(os.path.join(dirpath, name))
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer" or mode == "cell":
-            yield (astyle.style_default,
-                   "%s(%r)" % (self.__class__.__name__, self.base))
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "%s.%s(%r)" % \
-            (self.__class__.__module__, self.__class__.__name__, self.base)
-
-
-class ipwdentry(object):
-    """
-    ``ipwdentry`` objects encapsulate entries in the Unix user account and
-    password database.
-    """
-    def __init__(self, id):
-        self._id = id
-        self._entry = None
-
-    def __eq__(self, other):
-        return self.__class__ is other.__class__ and self._id == other._id
-
-    def __ne__(self, other):
-        return self.__class__ is not other.__class__ or self._id != other._id
-
-    def _getentry(self):
-        if self._entry is None:
-            if isinstance(self._id, basestring):
-                self._entry = pwd.getpwnam(self._id)
-            else:
-                self._entry = pwd.getpwuid(self._id)
-        return self._entry
-
-    def getname(self):
-        if isinstance(self._id, basestring):
-            return self._id
-        else:
-            return self._getentry().pw_name
-    name = property(getname, None, None, "User name")
-
-    def getpasswd(self):
-        return self._getentry().pw_passwd
-    passwd = property(getpasswd, None, None, "Password")
-
-    def getuid(self):
-        if isinstance(self._id, basestring):
-            return self._getentry().pw_uid
-        else:
-            return self._id
-    uid = property(getuid, None, None, "User id")
-
-    def getgid(self):
-        return self._getentry().pw_gid
-    gid = property(getgid, None, None, "Primary group id")
-
-    def getgroup(self):
-        return igrpentry(self.gid)
-    group = property(getgroup, None, None, "Group")
-
-    def getgecos(self):
-        return self._getentry().pw_gecos
-    gecos = property(getgecos, None, None, "Information (e.g. full user name)")
-
-    def getdir(self):
-        return self._getentry().pw_dir
-    dir = property(getdir, None, None, "$HOME directory")
-
-    def getshell(self):
-        return self._getentry().pw_shell
-    shell = property(getshell, None, None, "Login shell")
-
-    def __xattrs__(self, mode="default"):
-       return ("name", "passwd", "uid", "gid", "gecos", "dir", "shell")
-
-    def __repr__(self):
-        return "%s.%s(%r)" % \
-            (self.__class__.__module__, self.__class__.__name__, self._id)
-
-
-class ipwd(Table):
-    """
-    List all entries in the Unix user account and password database.
-
-    Example::
-
-        >>> ipwd | isort("uid")
-        <IPython.extensions.ipipe.isort key='uid' reverse=False at 0x849efec>
-        # random
-    """
-    def __iter__(self):
-        for entry in pwd.getpwall():
-            yield ipwdentry(entry.pw_name)
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer" or mode == "cell":
-            yield (astyle.style_default, "%s()" % self.__class__.__name__)
-        else:
-            yield (astyle.style_default, repr(self))
-
-
-class igrpentry(object):
-    """
-    ``igrpentry`` objects encapsulate entries in the Unix group database.
-    """
-    def __init__(self, id):
-        self._id = id
-        self._entry = None
-
-    def __eq__(self, other):
-        return self.__class__ is other.__class__ and self._id == other._id
-
-    def __ne__(self, other):
-        return self.__class__ is not other.__class__ or self._id != other._id
-
-    def _getentry(self):
-        if self._entry is None:
-            if isinstance(self._id, basestring):
-                self._entry = grp.getgrnam(self._id)
-            else:
-                self._entry = grp.getgrgid(self._id)
-        return self._entry
-
-    def getname(self):
-        if isinstance(self._id, basestring):
-            return self._id
-        else:
-            return self._getentry().gr_name
-    name = property(getname, None, None, "Group name")
-
-    def getpasswd(self):
-        return self._getentry().gr_passwd
-    passwd = property(getpasswd, None, None, "Password")
-
-    def getgid(self):
-        if isinstance(self._id, basestring):
-            return self._getentry().gr_gid
-        else:
-            return self._id
-    gid = property(getgid, None, None, "Group id")
-
-    def getmem(self):
-        return self._getentry().gr_mem
-    mem = property(getmem, None, None, "Members")
-
-    def __xattrs__(self, mode="default"):
-        return ("name", "passwd", "gid", "mem")
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer" or mode == "cell":
-            yield (astyle.style_default, "group ")
-            try:
-                yield (astyle.style_default, self.name)
-            except KeyError:
-                if isinstance(self._id, basestring):
-                    yield (astyle.style_default, self.name_id)
-                else:
-                    yield (astyle.style_type_number, str(self._id))
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __iter__(self):
-        for member in self.mem:
-            yield ipwdentry(member)
-
-    def __repr__(self):
-        return "%s.%s(%r)" % \
-            (self.__class__.__module__, self.__class__.__name__, self._id)
-
-
-class igrp(Table):
-    """
-    This ``Table`` lists all entries in the Unix group database.
-    """
-    def __iter__(self):
-        for entry in grp.getgrall():
-            yield igrpentry(entry.gr_name)
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer":
-            yield (astyle.style_default, "%s()" % self.__class__.__name__)
-        else:
-            yield (astyle.style_default, repr(self))
-
-
-class Fields(object):
-    def __init__(self, fieldnames, **fields):
-        self.__fieldnames = [upgradexattr(fieldname) for fieldname in fieldnames]
-        for (key, value) in fields.iteritems():
-            setattr(self, key, value)
-
-    def __xattrs__(self, mode="default"):
-        return self.__fieldnames
-
-    def __xrepr__(self, mode="default"):
-        yield (-1, False)
-        if mode == "header" or mode == "cell":
-            yield (astyle.style_default, self.__class__.__name__)
-            yield (astyle.style_default, "(")
-            for (i, f) in enumerate(self.__fieldnames):
-                if i:
-                    yield (astyle.style_default, ", ")
-                yield (astyle.style_default, f.name())
-                yield (astyle.style_default, "=")
-                for part in xrepr(getattr(self, f), "default"):
-                    yield part
-            yield (astyle.style_default, ")")
-        elif mode == "footer":
-            yield (astyle.style_default, self.__class__.__name__)
-            yield (astyle.style_default, "(")
-            for (i, f) in enumerate(self.__fieldnames):
-                if i:
-                    yield (astyle.style_default, ", ")
-                yield (astyle.style_default, f.name())
-            yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-
-class FieldTable(Table, list):
-    def __init__(self, *fields):
-        Table.__init__(self)
-        list.__init__(self)
-        self.fields = fields
-
-    def add(self, **fields):
-        self.append(Fields(self.fields, **fields))
-
-    def __xrepr__(self, mode="default"):
-        yield (-1, False)
-        if mode == "header" or mode == "footer":
-            yield (astyle.style_default, self.__class__.__name__)
-            yield (astyle.style_default, "(")
-            for (i, f) in enumerate(self.__fieldnames):
-                if i:
-                    yield (astyle.style_default, ", ")
-                yield (astyle.style_default, f)
-            yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "<%s.%s object with fields=%r at 0x%x>" % \
-            (self.__class__.__module__, self.__class__.__name__,
-             ", ".join(map(repr, self.fields)), id(self))
-
-
-class List(list):
-    def __xattrs__(self, mode="default"):
-        return xrange(len(self))
-
-    def __xrepr__(self, mode="default"):
-        yield (-1, False)
-        if mode == "header" or mode == "cell" or mode == "footer" or mode == "default":
-            yield (astyle.style_default, self.__class__.__name__)
-            yield (astyle.style_default, "(")
-            for (i, item) in enumerate(self):
-                if i:
-                    yield (astyle.style_default, ", ")
-                for part in xrepr(item, "default"):
-                    yield part
-            yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-
-class ienv(Table):
-    """
-    List environment variables.
-
-    Example::
-
-        >>> ienv
-        <class 'IPython.extensions.ipipe.ienv'>
-    """
-
-    def __iter__(self):
-        fields = ("key", "value")
-        for (key, value) in os.environ.iteritems():
-            yield Fields(fields, key=key, value=value)
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "cell":
-            yield (astyle.style_default, "%s()" % self.__class__.__name__)
-        else:
-            yield (astyle.style_default, repr(self))
-
-
-class ihist(Table):
-    """
-    IPython input history
-
-    Example::
-
-        >>> ihist
-        <class 'IPython.extensions.ipipe.ihist'>
-        >>> ihist(True) # raw mode
-        <IPython.extensions.ipipe.ihist object at 0x849602c>  # random
-    """
-    def __init__(self, raw=True):
-        self.raw = raw
-
-    def __iter__(self):
-        api = ipapi.get()
-        if self.raw:
-            for line in api.input_hist_raw:
-                yield line.rstrip("\n")
-        else:
-            for line in api.input_hist:
-                yield line.rstrip("\n")
-
-
-class Alias(object):
-    """
-    Entry in the alias table
-    """
-    def __init__(self, name, args, command):
-        self.name = name
-        self.args = args
-        self.command = command
-
-    def __xattrs__(self, mode="default"):
-        return ("name", "args", "command")
-
-
-class ialias(Table):
-    """
-    IPython alias list
-
-    Example::
-
-        >>> ialias
-        <class 'IPython.extensions.ipipe.ialias'>
-    """
-    def __iter__(self):
-        api = ipapi.get()
-
-        for (name, (args, command)) in api.alias_manager.alias_table.iteritems():
-            yield Alias(name, args, command)
-
-
-class icsv(Pipe):
-    """
-    This ``Pipe`` turns the input (with must be a pipe outputting lines
-    or an ``ifile``) into lines of CVS columns.
-    """
-    def __init__(self, **csvargs):
-        """
-        Create an ``icsv`` object. ``cvsargs`` will be passed through as
-        keyword arguments to ``cvs.reader()``.
-        """
-        self.csvargs = csvargs
-
-    def __iter__(self):
-        input = self.input
-        if isinstance(input, ifile):
-            input = input.open("rb")
-        reader = csv.reader(input, **self.csvargs)
-        for line in reader:
-            yield List(line)
-
-    def __xrepr__(self, mode="default"):
-        yield (-1, False)
-        if mode == "header" or mode == "footer":
-            input = getattr(self, "input", None)
-            if input is not None:
-                for part in xrepr(input, mode):
-                    yield part
-                yield (astyle.style_default, " | ")
-            yield (astyle.style_default, "%s(" % self.__class__.__name__)
-            for (i, (name, value)) in enumerate(self.csvargs.iteritems()):
-                if i:
-                    yield (astyle.style_default, ", ")
-                yield (astyle.style_default, name)
-                yield (astyle.style_default, "=")
-                for part in xrepr(value, "default"):
-                    yield part
-            yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        args = ", ".join(["%s=%r" % item for item in self.csvargs.iteritems()])
-        return "<%s.%s %s at 0x%x>" % \
-        (self.__class__.__module__, self.__class__.__name__, args, id(self))
-
-
-class ix(Table):
-    """
-    Execute a system command and list its output as lines
-    (similar to ``os.popen()``).
-
-    Examples::
-
-        >>> ix("ps x")
-        IPython.extensions.ipipe.ix('ps x')
-
-        >>> ix("find .") | ifile
-        <IPython.extensions.ipipe.ieval expr=<class 'IPython.extensions.ipipe.ifile'> at 0x8509d2c>
-        # random
-    """
-    def __init__(self, cmd):
-        self.cmd = cmd
-        self._pipeout = None
-
-    def __iter__(self):
-        (_pipein, self._pipeout) = os.popen4(self.cmd)
-        _pipein.close()
-        for l in self._pipeout:
-            yield l.rstrip("\r\n")
-        self._pipeout.close()
-        self._pipeout = None
-
-    def __del__(self):
-        if self._pipeout is not None and not self._pipeout.closed:
-            self._pipeout.close()
-        self._pipeout = None
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer":
-            yield (astyle.style_default,
-                   "%s(%r)" % (self.__class__.__name__, self.cmd))
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "%s.%s(%r)" % \
-            (self.__class__.__module__, self.__class__.__name__, self.cmd)
-
-
-class ifilter(Pipe):
-    """
-    Filter an input pipe. Only objects where an expression evaluates to true
-    (and doesn't raise an exception) are listed.
-
-    Examples::
-
-        >>> ils | ifilter("_.isfile() and size>1000")
-        >>> igrp | ifilter("len(mem)")
-        >>> sys.modules | ifilter(lambda _:_.value is not None)
-        # all-random
-    """
-
-    def __init__(self, expr, globals=None, errors="raiseifallfail"):
-        """
-        Create an ``ifilter`` object. ``expr`` can be a callable or a string
-        containing an expression. ``globals`` will be used as the global
-        namespace for calling string expressions (defaulting to IPython's
-        user namespace). ``errors`` specifies how exception during evaluation
-        of ``expr`` are handled:
-
-        ``"drop"``
-            drop all items that have errors;
-
-        ``"keep"``
-            keep all items that have errors;
-
-        ``"keeperror"``
-            keep the exception of all items that have errors;
-
-        ``"raise"``
-            raise the exception;
-
-        ``"raiseifallfail"``
-            raise the first exception if all items have errors; otherwise drop
-            those with errors (this is the default).
-        """
-        self.expr = expr
-        self.globals = globals
-        self.errors = errors
-
-    def __iter__(self):
-        if callable(self.expr):
-            test = self.expr
-        else:
-            g = getglobals(self.globals)
-            expr = compile(self.expr, "ipipe-expression", "eval")
-            def test(item):
-                return eval(expr, g, AttrNamespace(item))
-
-        ok = 0
-        exc_info = None
-        for item in xiter(self.input):
-            try:
-                if test(item):
-                    yield item
-                ok += 1
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception as exc:
-                if self.errors == "drop":
-                    pass # Ignore errors
-                elif self.errors == "keep":
-                    yield item
-                elif self.errors == "keeperror":
-                    yield exc
-                elif self.errors == "raise":
-                    raise
-                elif self.errors == "raiseifallfail":
-                    if exc_info is None:
-                        exc_info = sys.exc_info()
-        if not ok and exc_info is not None:
-            raise exc_info[0], exc_info[1], exc_info[2]
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer":
-            input = getattr(self, "input", None)
-            if input is not None:
-                for part in xrepr(input, mode):
-                    yield part
-                yield (astyle.style_default, " | ")
-            yield (astyle.style_default, "%s(" % self.__class__.__name__)
-            for part in xrepr(self.expr, "default"):
-                yield part
-            yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "<%s.%s expr=%r at 0x%x>" % \
-            (self.__class__.__module__, self.__class__.__name__,
-             self.expr, id(self))
-
-
-class ieval(Pipe):
-    """
-    Evaluate an expression for each object in the input pipe.
-
-    Examples::
-
-        >>> ils | ieval("_.abspath()")
-        # random
-        >>> sys.path | ieval(ifile)
-        # random
-    """
-
-    def __init__(self, expr, globals=None, errors="raiseifallfail"):
-        """
-        Create an ``ieval`` object. ``expr`` can be a callable or a string
-        containing an expression. For the meaning of ``globals`` and
-        ``errors`` see ``ifilter``.
-        """
-        self.expr = expr
-        self.globals = globals
-        self.errors = errors
-
-    def __iter__(self):
-        if callable(self.expr):
-            do = self.expr
-        else:
-            g = getglobals(self.globals)
-            expr = compile(self.expr, "ipipe-expression", "eval")
-            def do(item):
-                return eval(expr, g, AttrNamespace(item))
-
-        ok = 0
-        exc_info = None
-        for item in xiter(self.input):
-            try:
-                yield do(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception as exc:
-                if self.errors == "drop":
-                    pass # Ignore errors
-                elif self.errors == "keep":
-                    yield item
-                elif self.errors == "keeperror":
-                    yield exc
-                elif self.errors == "raise":
-                    raise
-                elif self.errors == "raiseifallfail":
-                    if exc_info is None:
-                        exc_info = sys.exc_info()
-        if not ok and exc_info is not None:
-            raise exc_info[0], exc_info[1], exc_info[2]
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer":
-            input = getattr(self, "input", None)
-            if input is not None:
-                for part in xrepr(input, mode):
-                    yield part
-                yield (astyle.style_default, " | ")
-            yield (astyle.style_default, "%s(" % self.__class__.__name__)
-            for part in xrepr(self.expr, "default"):
-                yield part
-            yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "<%s.%s expr=%r at 0x%x>" % \
-            (self.__class__.__module__, self.__class__.__name__,
-             self.expr, id(self))
-
-
-class ienum(Pipe):
-    """
-    Enumerate the input pipe (i.e. wrap each input object in an object
-    with ``index`` and ``object`` attributes).
-
-    Examples::
-
-        >>> xrange(20) | ieval("_,_*_") | ienum | ifilter("index % 2 == 0") | ieval("object")
-    """
-    skip_doctest = True
-    
-    def __iter__(self):
-        fields = ("index", "object")
-        for (index, object) in enumerate(xiter(self.input)):
-            yield Fields(fields, index=index, object=object)
-
-
-class isort(Pipe):
-    """
-    Sorts the input pipe.
-
-    Examples::
-
-        >>> ils | isort("size")
-        <IPython.extensions.ipipe.isort key='size' reverse=False at 0x849ec2c>
-        >>> ils | isort("_.isdir(), _.lower()", reverse=True)
-        <IPython.extensions.ipipe.isort key='_.isdir(), _.lower()' reverse=True at 0x849eacc>
-        # all-random
-    """
-
-    def __init__(self, key=None, globals=None, reverse=False):
-        """
-        Create an ``isort`` object. ``key`` can be a callable or a string
-        containing an expression (or ``None`` in which case the items
-        themselves will be sorted). If ``reverse`` is true the sort order
-        will be reversed. For the meaning of ``globals`` see ``ifilter``.
-        """
-        self.key = key
-        self.globals = globals
-        self.reverse = reverse
-
-    def __iter__(self):
-        if self.key is None:
-            items = sorted(xiter(self.input), reverse=self.reverse)
-        elif callable(self.key):
-            items = sorted(xiter(self.input), key=self.key, reverse=self.reverse)
-        else:
-            g = getglobals(self.globals)
-            key = compile(self.key, "ipipe-expression", "eval")
-            def realkey(item):
-                return eval(key, g, AttrNamespace(item))
-            items = sorted(xiter(self.input), key=realkey, reverse=self.reverse)
-        for item in items:
-            yield item
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer":
-            input = getattr(self, "input", None)
-            if input is not None:
-                for part in xrepr(input, mode):
-                    yield part
-                yield (astyle.style_default, " | ")
-            yield (astyle.style_default, "%s(" % self.__class__.__name__)
-            for part in xrepr(self.key, "default"):
-                yield part
-            if self.reverse:
-                yield (astyle.style_default, ", ")
-                for part in xrepr(True, "default"):
-                    yield part
-            yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "<%s.%s key=%r reverse=%r at 0x%x>" % \
-            (self.__class__.__module__, self.__class__.__name__,
-             self.key, self.reverse, id(self))
-
-
-tab = 3 # for expandtabs()
-
-def _format(field):
-    if isinstance(field, str):
-        text = repr(field.expandtabs(tab))[1:-1]
-    elif isinstance(field, unicode):
-        text = repr(field.expandtabs(tab))[2:-1]
-    elif isinstance(field, datetime.datetime):
-        # Don't use strftime() here, as this requires year >= 1900
-        text = "%04d-%02d-%02d %02d:%02d:%02d.%06d" % \
-            (field.year, field.month, field.day,
-             field.hour, field.minute, field.second, field.microsecond)
-    elif isinstance(field, datetime.date):
-        text = "%04d-%02d-%02d" % (field.year, field.month, field.day)
-    else:
-        text = repr(field)
-    return text
-
-
-class Display(object):
-    class __metaclass__(type):
-        def __ror__(self, input):
-            return input | self()
-
-    def __init__(self, input=None):
-        self.input = input
-
-    def __ror__(self, input):
-        self.input = input
-        return self
-
-    def display(self):
-        pass
-
-
-class iless(Display):
-    cmd = "less --quit-if-one-screen --LONG-PROMPT --LINE-NUMBERS --chop-long-lines --shift=8 --RAW-CONTROL-CHARS"
-
-    def display(self):
-        try:
-            pager = os.popen(self.cmd, "w")
-            try:
-                for item in xiter(self.input):
-                    first = False
-                    for attr in xattrs(item, "default"):
-                        if first:
-                            first = False
-                        else:
-                            pager.write(" ")
-                        attr = upgradexattr(attr)
-                        if not isinstance(attr, SelfDescriptor):
-                            pager.write(attr.name())
-                            pager.write("=")
-                        pager.write(str(attr.value(item)))
-                    pager.write("\n")
-            finally:
-                pager.close()
-        except Exception as exc:
-            print "%s: %s" % (exc.__class__.__name__, str(exc))
-
-
-class _RedirectIO(object):
-    def __init__(self,*args,**kwargs):
-        """
-        Map the system output streams to self.
-        """
-        self.stream = StringIO.StringIO()
-        self.stdout = sys.stdout
-        sys.stdout = self
-        self.stderr = sys.stderr
-        sys.stderr = self
-
-    def write(self, text):
-        """
-        Write both to screen and to self.
-        """
-        self.stream.write(text)
-        self.stdout.write(text)
-        if "\n" in text:
-            self.stdout.flush()
-
-    def writelines(self, lines):
-        """
-        Write lines both to screen and to self.
-        """
-        self.stream.writelines(lines)
-        self.stdout.writelines(lines)
-        self.stdout.flush()
-
-    def restore(self):
-        """
-        Restore the default system streams.
-        """
-        self.stdout.flush()
-        self.stderr.flush()
-        sys.stdout = self.stdout
-        sys.stderr = self.stderr
-
-
-class icap(Table):
-    """
-    Execute a python string and capture any output to stderr/stdout.
-
-    Examples::
-
-        >>> import time
-        >>> icap("for i in range(10): print i, time.sleep(0.1)")
-
-    """
-    skip_doctest = True
-    
-    def __init__(self, expr, globals=None):
-        self.expr = expr
-        self.globals = globals
-        log = _RedirectIO()
-        try:
-            exec(expr, getglobals(globals))
-        finally:
-            log.restore()
-        self.stream = log.stream
-
-    def __iter__(self):
-        self.stream.seek(0)
-        for line in self.stream:
-            yield line.rstrip("\r\n")
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer":
-            yield (astyle.style_default,
-                   "%s(%r)" % (self.__class__.__name__, self.expr))
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "%s.%s(%r)" % \
-            (self.__class__.__module__, self.__class__.__name__, self.expr)
-
-
-def xformat(value, mode, maxlength):
-    align = None
-    full = True
-    width = 0
-    text = astyle.Text()
-    for (style, part) in xrepr(value, mode):
-        # only consider the first result
-        if align is None:
-            if isinstance(style, int):
-                # (style, text) really is (alignment, stop)
-                align = style
-                full = part
-                continue
-            else:
-                align = -1
-                full = True
-        if not isinstance(style, int):
-            text.append((style, part))
-            width += len(part)
-            if width >= maxlength and not full:
-                text.append((astyle.style_ellisis, "..."))
-                width += 3
-                break
-    if align is None: # default to left alignment
-        align = -1
-    return (align, width, text)
-
-
-
-import astyle
-
-class idump(Display):
-    # The approximate maximum length of a column entry
-    maxattrlength = 200
-
-    # Style for column names
-    style_header = astyle.Style.fromstr("white:black:bold")
-
-    def __init__(self, input=None, *attrs):
-        Display.__init__(self, input)
-        self.attrs = [upgradexattr(attr) for attr in attrs]
-        self.headerpadchar = " "
-        self.headersepchar = "|"
-        self.datapadchar = " "
-        self.datasepchar = "|"
-
-    def display(self):
-        stream = Term.cout
-        allattrs = []
-        attrset = set()
-        colwidths = {}
-        rows = []
-        for item in xiter(self.input):
-            row = {}
-            attrs = self.attrs
-            if not attrs:
-                attrs = xattrs(item, "default")
-            for attr in attrs:
-                if attr not in attrset:
-                    allattrs.append(attr)
-                    attrset.add(attr)
-                    colwidths[attr] = len(attr.name())
-                try:
-                    value = attr.value(item)
-                except (KeyboardInterrupt, SystemExit):
-                    raise
-                except Exception as exc:
-                    value = exc
-                (align, width, text) = xformat(value, "cell", self.maxattrlength)
-                colwidths[attr] = max(colwidths[attr], width)
-                # remember alignment, length and colored parts
-                row[attr] = (align, width, text)
-            rows.append(row)
-
-        stream.write("\n")
-        for (i, attr) in enumerate(allattrs):
-            attrname = attr.name()
-            self.style_header(attrname).write(stream)
-            spc = colwidths[attr] - len(attrname)
-            if i < len(colwidths)-1:
-                stream.write(self.headerpadchar*spc)
-                stream.write(self.headersepchar)
-        stream.write("\n")
-
-        for row in rows:
-            for (i, attr) in enumerate(allattrs):
-                (align, width, text) = row[attr]
-                spc = colwidths[attr] - width
-                if align == -1:
-                    text.write(stream)
-                    if i < len(colwidths)-1:
-                        stream.write(self.datapadchar*spc)
-                elif align == 0:
-                    spc = colwidths[attr] - width
-                    spc1 = spc//2
-                    spc2 = spc-spc1
-                    stream.write(self.datapadchar*spc1)
-                    text.write(stream)
-                    if i < len(colwidths)-1:
-                        stream.write(self.datapadchar*spc2)
-                else:
-                    stream.write(self.datapadchar*spc)
-                    text.write(stream)
-                if i < len(colwidths)-1:
-                    stream.write(self.datasepchar)
-            stream.write("\n")
-
-
-class AttributeDetail(Table):
-    """
-    ``AttributeDetail`` objects are use for displaying a detailed list of object
-    attributes.
-    """
-    def __init__(self, object, descriptor):
-        self.object = object
-        self.descriptor = descriptor
-
-    def __iter__(self):
-        return self.descriptor.iter(self.object)
-
-    def name(self):
-        return self.descriptor.name()
-
-    def attrtype(self):
-        return self.descriptor.attrtype(self.object)
-
-    def valuetype(self):
-        return self.descriptor.valuetype(self.object)
-
-    def doc(self):
-        return self.descriptor.doc(self.object)
-
-    def shortdoc(self):
-        return self.descriptor.shortdoc(self.object)
-
-    def value(self):
-        return self.descriptor.value(self.object)
-
-    def __xattrs__(self, mode="default"):
-        attrs = ("name()", "attrtype()", "valuetype()", "value()", "shortdoc()")
-        if mode == "detail":
-            attrs += ("doc()",)
-        return attrs
-
-    def __xrepr__(self, mode="default"):
-        yield (-1, True)
-        valuetype = self.valuetype()
-        if valuetype is not noitem:
-            for part in xrepr(valuetype):
-                yield part
-            yield (astyle.style_default, " ")
-        yield (astyle.style_default, self.attrtype())
-        yield (astyle.style_default, " ")
-        yield (astyle.style_default, self.name())
-        yield (astyle.style_default, " of ")
-        for part in xrepr(self.object):
-            yield part
-
-
-try:
-    from ibrowse import ibrowse
-except ImportError:
-    # No curses (probably Windows) => try igrid
-    try:
-        from igrid import igrid
-    except ImportError:
-        # no wx either => use ``idump`` as the default display.
-        defaultdisplay = idump
-    else:
-        defaultdisplay = igrid
-        __all__.append("igrid")
-else:
-    defaultdisplay = ibrowse
-    __all__.append("ibrowse")
-
-
-# If we're running under IPython, register our objects with IPython's
-# generic function ``result_display``, else install a displayhook
-# directly as sys.displayhook
-if generics is not None:
-    def display_display(obj):
-        return obj.display()
-    generics.result_display.when_type(Display)(display_display)
-
-    def display_tableobject(obj):
-        return display_display(defaultdisplay(obj))
-    generics.result_display.when_type(Table)(display_tableobject)
-
-    def display_tableclass(obj):
-        return display_tableobject(obj())
-    generics.result_display.when_type(Table.__metaclass__)(display_tableclass)
-else:
-    def installdisplayhook():
-        _originalhook = sys.displayhook
-        def displayhook(obj):
-            if isinstance(obj, type) and issubclass(obj, Table):
-                obj = obj()
-            if isinstance(obj, Table):
-                obj = defaultdisplay(obj)
-            if isinstance(obj, Display):
-                return obj.display()
-            else:
-                _originalhook(obj)
-        sys.displayhook = displayhook
-    installdisplayhook()

IPython/deathrow/iplib.py

@@ -1,28 +0,0 b''
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-A backwards compatibility layer for IPython.iplib.
-
-Previously, IPython had an IPython.iplib module.  IPython.iplib has been moved
-to IPython.core.iplib and is being refactored.  This new module is provided
-for backwards compatability.  We strongly encourage everyone to start using
-the new code in IPython.core.iplib.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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.
-#-----------------------------------------------------------------------------
-
-from warnings import warn
-
-msg = """
-This module (IPython.iplib) has been moved to a new location
-(IPython.core.iplib) and is being refactored.  Please update your code
-to use the new IPython.core.iplib module"""
-
-warn(msg, category=DeprecationWarning, stacklevel=1)
-
-from IPython.core.iplib import *

IPython/deathrow/ipy_constants.py

@@ -1,669 +0,0 b''
-""" Module with physical constants for use with ipython, profile
-"physics".
-
-Definition of Fundamental Physical Constants, CODATA Recommended Values
-
-Source, Peter J. Mohr and Barry N. Taylor,
-CODATA Recommended Values of the Fundamental
-Physical Constants, 1998
-
-Website: physics.nist.gov/constants
-"""
-# License: BSD-like
-# Copyright: Gael Varoquaux ([e-mail])
-
-# inspired by maxima's physconst.mac by Cliff Yapp
-
-#from math import * # math MUST be imported BEFORE PhysicalQInteractive
-from IPython.extensions.PhysicalQInteractive import PhysicalQuantityInteractive
-
-# Math constants:
-
-# Pi mathematical constants
-pi = 3.141592653589793238462643383279502884197169399375105820974944592
-
-# Universal Constants
-#-------------------------------------------------------------------------
-
-c = PhysicalQuantityInteractive(299792458 , 'm/s')
-c.__doc__ = """speed of light in vacuum"""
-c.__doc__ = "speed of light in vacuum"
-
-u_0 = PhysicalQuantityInteractive(4*pi*1E-7 , 'N/(A**2)')
-u_0.__doc__ = """magnetic constant"""
-mu_0 = PhysicalQuantityInteractive(4*pi*1E-7 , 'N/(A**2)')
-
-epsilon_0 = PhysicalQuantityInteractive(8.854187817E-12 , 'F/m')
-epsilon_0.__doc__ = """electric constant """
-
-Z_0 = PhysicalQuantityInteractive(376.730313461 , 'ohm')
-Z_0.__doc__ = """characteristic impedance of vacuum """
-
-G = PhysicalQuantityInteractive(6.673E-11 , 'm**3/(kg*s**2)')
-G.__doc__ = """Newtonian constant of gravitation    """
-
-
-h = PhysicalQuantityInteractive(6.62606876E-34 , 'J*s')
-h.__doc__ = """Planck constant    """
-
-
-h_eV = PhysicalQuantityInteractive(4.13566727E-15 , 'eV*s')
-h_eV.__doc__ = """Planck constant in eVs  """
-
-
-h_bar = PhysicalQuantityInteractive(1.054571596E-34 , 'J*s')
-h_bar.__doc__ = """Hbar"""
-
-
-h_bar_eV = PhysicalQuantityInteractive(6.58211889E-16 , 'eV*s')
-h_bar_eV.__doc__ = """Hbar in eV"""
-
-
-P_m = PhysicalQuantityInteractive(2.1767E-8 , 'kg')
-P_m.__doc__ = """Planck mass"""
-
-
-P_l = PhysicalQuantityInteractive(1.6160E-35 , 'm')
-P_l.__doc__ = """Planck length  """
-
-
-P_t = PhysicalQuantityInteractive(5.3906E-44 , 's')
-P_t.__doc__ = """Planck time """
-
-# Electromagnetic Constants
-#------------------------------------------------------------------------
-
-_e = PhysicalQuantityInteractive(1.602176462E-19 , 'C')
-_e.__doc__ = """elementary charge"""
-q = _e
-
-
-capitalphi_0 = PhysicalQuantityInteractive(2.067833636E-15 , 'Wb')
-capitalphi_0.__doc__ = """magnetic flux quantum """
-mfq_0 = PhysicalQuantityInteractive(2.067833636E-15 , 'Wb')
-
-
-G_0 = PhysicalQuantityInteractive(7.748091696E-5 , 'S')
-G_0.__doc__ = """conductance quantum """
-
-
-K_J = PhysicalQuantityInteractive(483597.898E9 , 'Hz/V')
-K_J.__doc__ = """Josephson constant"""
-
-
-R_K = PhysicalQuantityInteractive(25812.807572 , 'ohm')
-R_K.__doc__ = """von Klitzing constant"""
-
-
-u_B = PhysicalQuantityInteractive(927.400899E-26 , 'J/T')
-u_B.__doc__ = """Bohr magneton"""
-
-ueVT_B = PhysicalQuantityInteractive(5.788381749E-5 , 'eV/T')
-ueVT_B.__doc__ = """Bohr magneton in eV T-1"""
-
-
-u_N = PhysicalQuantityInteractive(5.05078317E-27 , 'J/T')
-u_N.__doc__ = """nuclear magneton """
-
-ueVT_N = PhysicalQuantityInteractive(3.152451238E-8 , 'eV/T')
-ueVT_N.__doc__ = """nuclear magneton in eV T-1      """
-
-# Atomic and Nuclear Constants
-# General
-#-------------------------------------------------------------------------
-# fine-structure constant
-alpha = 7.297352533E-3
-
-
-Ry = PhysicalQuantityInteractive(10973731.568549 , '1/m')
-Ry.__doc__ = """Rydberg constant  """
-Ry_INF = PhysicalQuantityInteractive(10973731.568549 , '1/m')
-
-
-a_0 = PhysicalQuantityInteractive(0.5291772083E-10 , 'm')
-a_0.__doc__ = """Bohr radius """
-
-
-E_h = PhysicalQuantityInteractive(4.35974381E-18 , 'J')
-E_h.__doc__ = """Hartree energy """
-
-Eev_h = PhysicalQuantityInteractive(27.2113834 , 'eV')
-Eev_h.__doc__ = """Hartree energy in eV    """
-
-
-qcir2 = PhysicalQuantityInteractive(3.636947516E-4 , 'm**2/s')
-qcir2.__doc__ = """quantum of circulation   h/(2me) """
-
-qcir = PhysicalQuantityInteractive(7.273895032E-4 , 'm**2/s')
-qcir.__doc__ = """quantum of circulation   h/(me) """
-
-# Electroweak
-#-------------------------------------------------------------------------
-
-Fcc = PhysicalQuantityInteractive(1.16639E-5 , '1/GeV**2')
-Fcc.__doc__ = """Fermi coupling constant    """
-# weak mixing angled  W (on-shell scheme)
-wma_W = 0.2224
-
-# Electron, e-
-#-------------------------------------------------------------------------
-
-m_e = PhysicalQuantityInteractive(9.10938188E-31 , 'kg')
-m_e.__doc__ = """electron mass    """
-
-m_e_u = PhysicalQuantityInteractive(5.485799110E-4 , 'amu')
-m_e_u.__doc__ = """electron mass (electron relative atomic mass times amu)"""
-
-me_J = PhysicalQuantityInteractive(8.18710414E-14 , 'J')
-me_J.__doc__ = """electron mass - energy equivalent    """
-
-me_MeV = PhysicalQuantityInteractive(0.510998902 , 'MeV')
-me_MeV.__doc__ = """electron mass - energy equivalent in MeV"""
-
-# electron-muon mass ratio
-memu = 4.83633210E-3
-
-# electron-tau mass ratio
-metau = 2.87555E-4
-
-# electron-proton mass ratio
-memp = 5.446170232E-4
-
-# electron-neutron mass ratio
-memn = 5.438673462E-4
-
-# electron-deuteron mass ratio
-memd = 2.7244371170E-4
-
-# electron to alpha particle mass ratio
-memalpha = 1.3709335611E-4
-
-
-echargeemass = PhysicalQuantityInteractive(-1.758820174E11 , 'C/kg')
-echargeemass.__doc__ = """electron charge to mass quotient    """
-
-
-Molar_e = PhysicalQuantityInteractive(5.485799110E-7 , 'kg/mol')
-Molar_e.__doc__ = """electron molar mass     """
-
-
-lambdaC = PhysicalQuantityInteractive(2.426310215E-12 , 'm')
-lambdaC.__doc__ = """Compton wavelength """
-
-
-r_e = PhysicalQuantityInteractive(2.817940285E-15 , 'm')
-r_e.__doc__ = """classical electron radius  """
-
-
-sigma_e = PhysicalQuantityInteractive(0.665245854E-28 , 'm**2')
-sigma_e.__doc__ = """Thomson cross section """
-
-
-u_e = PhysicalQuantityInteractive(-928.476362E-26 , 'J/T')
-u_e.__doc__ = """electron magnetic moment    """
-
-# electron magnetic moment to Bohr magneton ratio
-ueuB = -1.0011596521869
-
-# electron magnetic moment to nuclear magneton ratio
-ueuN = -1838.2819660
-
-# electron magnetic moment anomaly |ue|/uB - 1
-a_e = 1.1596521869E-3
-
-# electron g-factor
-g_e = -2.0023193043737
-
-# electron-muon magnetic moment ratio
-ueuu = 206.7669720
-
-# electron-proton magnetic moment ratio
-ueup = -658.2106875
-
-# electron to shielded proton magnetic moment ratio  (H2O, sphere, 25  C)
-ueusp = -658.2275954
-
-# electron-neutron magnetic moment ratio
-ueun = 960.92050
-
-# electron-deuteron magnetic moment ratio
-ueud = -2143.923498
-
-# electron to shielded helione magnetic moment ratio  (gas, sphere, 25  C)
-ueush = 864.058255
-
-
-gamma_e = PhysicalQuantityInteractive(1.760859794E11 , '1/(s*T)')
-gamma_e.__doc__ = """electron gyromagnetic ratio """
-
-# Muon, u-
-#-------------------------------------------------------------------------
-
-m_u = PhysicalQuantityInteractive(1.88353109E-28 , 'kg')
-m_u.__doc__ = """muon mass    """
-
-mu_u = PhysicalQuantityInteractive(0.1134289168 , 'amu')
-mu_u.__doc__ = """muon mass in muon relative atomic mass times amu    """
-
-
-muc2_J = PhysicalQuantityInteractive(1.69283332E-11 , 'J')
-muc2_J.__doc__ = """energy equivalent    """
-
-muc2_MeV = PhysicalQuantityInteractive(105.6583568 , 'MeV')
-muc2_MeV.__doc__ = """energy equivalent in MeV """
-
-# muon-electron mass ratio
-mume = 206.7682657
-
-# muon-tau mass ratio
-mum = 5.94572E-2
-
-# muon-proton mass ratio
-mump = 0.1126095173
-
-# muon-neutron mass ratio
-mumn = 0.1124545079
-
-
-Molar_u = PhysicalQuantityInteractive(0.1134289168E-3 , 'kg/mol')
-Molar_u.__doc__ = """muon molar mass """
-
-
-lambda_C_u = PhysicalQuantityInteractive(11.73444197E-15 , 'm')
-lambda_C_u.__doc__ = """muon Compton wavelength """
-
-
-uu = PhysicalQuantityInteractive(-4.49044813E-26 , 'J/T')
-uu.__doc__ = """muon magnetic moment    """
-
-# ratio of muon magnetic moment to Bohr magneton ratio
-uuuB = -4.84197085E-3
-
-# ratio of muon magnetic moment to nuclear magneton ratio
-uuuN = -8.89059770
-
-# muon magnetic moment anomaly |uu|/(e /2mu) - 1
-a_u = 1.16591602E-3
-
-# muon g-factor -2(1 + au)
-g_u = -2.0023318320
-
-# muon-proton magnetic moment ratio
-uuup = -3.18334539
-
-# Tau, tau-
-#-------------------------------------------------------------------------
-
-m_tau = PhysicalQuantityInteractive(3.16788E-27 , 'kg')
-m_tau.__doc__ = """tau mass    """
-
-mu_tau = PhysicalQuantityInteractive(1.90774 , 'amu')
-mu_tau.__doc__ = """tau mass  (tau relative atomic mass times amu)   """
-
-
-mtauc2_J = PhysicalQuantityInteractive(2.84715E-10 , 'J')
-mtauc2_J.__doc__ = """tau mass energy equivalent    """
-
-
-mtauc2_MeV = PhysicalQuantityInteractive(1777.05 , 'MeV')
-mtauc2_MeV.__doc__ = """tau mass energy equivalent in MeV """
-
-# tau-electron mass ratio
-mtaume = 3477.60
-
-# tau-muon mass ratio
-mtaumu = 16.8188
-
-# tau-proton mass ratio
-mtaump = 1.89396
-
-# tau-neutron mass ratio
-mtaumn = 1.89135
-
-
-Molar_tau = PhysicalQuantityInteractive(1.90774E-3 , 'kg/mol')
-Molar_tau.__doc__ = """tau molar mass """
-
-
-lambda_C_tau = PhysicalQuantityInteractive(0.69770E-15 , 'm')
-lambda_C_tau.__doc__ = """tau Compton wavelength    """
-
-# Proton, p
-#-------------------------------------------------------------------------
-
-m_p = PhysicalQuantityInteractive(1.67262158E-27 , 'kg')
-m_p.__doc__ = """proton mass  """
-
-mu_p = PhysicalQuantityInteractive(1.00727646688 , 'amu')
-mu_p.__doc__ = """proton mass (proton relative atomic mass times amu)  """
-
-
-mpc2_J = PhysicalQuantityInteractive(1.50327731E-10 , 'J')
-mpc2_J.__doc__ = """energy equivalent   """
-
-mpc2_MeV = PhysicalQuantityInteractive(938.271998 , 'MeV')
-mpc2_MeV.__doc__ = """energy equivalent in MeV  """
-
-# proton-electron mass ratio
-mpme = 1836.1526675
-
-# proton-muon mass ratio
-mpmu = 8.88024408
-
-# proton-tau mass ratio
-mpmtau = 0.527994
-
-# proton-neutron mass ratio
-mpmn = 0.99862347855
-
-
-emp = PhysicalQuantityInteractive(9.57883408E7 , 'C/kg')
-emp.__doc__ = """proton charge to mass quotient    """
-
-
-Molar_p = PhysicalQuantityInteractive(1.00727646688E-3 , 'kg/mol')
-Molar_p.__doc__ = """proton molar mass """
-
-
-lambda_C_p = PhysicalQuantityInteractive(1.321409847E-15 , 'm')
-lambda_C_p.__doc__ = """proton Compton wavelength h/mpc  """
-
-
-up = PhysicalQuantityInteractive(1.410606633E-26 , 'J/T')
-up.__doc__ = """proton magnetic moment   """
-
-# proton magnetic moment to Bohr magneton ratio
-upuB = 1.521032203E-3
-
-# proton magnetic moment to nuclear magneton ratio
-upuN = 2.792847337
-
-# proton g-factor 2up/uN
-g_p = 5.585694675
-
-# proton-neutron magnetic moment ratio
-upun = -1.45989805
-
-
-usp = PhysicalQuantityInteractive(1.410570399E-26 , 'J/T')
-usp.__doc__ = """shielded proton magnetic moment  (H2O, sphere, 25  C)"""
-
-# shielded proton magnetic moment to Bohr magneton ratio
-uspuB = 1.520993132E-3
-
-# shielded proton magnetic moment to nuclear magneton ratio
-uspuN = 2.792775597
-
-# proton magnetic shielding correction 1 - u p/up  (H2O, sphere, 25  C)
-spc = 25.687E-6
-
-
-gamma_p = PhysicalQuantityInteractive(2.67522212E8 , '1/(s*T)')
-gamma_p.__doc__ = """proton gyromagnetic ratio """
-
-
-gamma_sp = PhysicalQuantityInteractive(2.67515341E8 , '1/(s*T)')
-gamma_sp.__doc__ = """shielded proton gyromagnetic ratio (H2O, sphere, 25  C)"""
-
-# Neutron, n
-#-------------------------------------------------------------------------
-
-m_n = PhysicalQuantityInteractive(1.67492716E-27 , 'kg')
-m_n.__doc__ = """neutron mass  """
-
-mu_n = PhysicalQuantityInteractive(1.00866491578 , 'amu')
-mu_n.__doc__ = """neutron mass (neutron relative atomic mass times amu) """
-
-
-mnc2_J = PhysicalQuantityInteractive(1.50534946E-10 , 'J')
-mnc2_J.__doc__ = """neutron mass energy equivalent  """
-
-
-mnc2_MeV = PhysicalQuantityInteractive(939.565330 , 'MeV')
-mnc2_MeV.__doc__ = """neutron mass energy equivalent  in MeV  """
-
-# neutron-electron mass ratio
-mnme = 1838.6836550
-
-# neutron-muon mass ratio
-mnmu = 8.89248478
-
-# neutron-tau mass ratio
-mnm = 0.528722
-
-# neutron-proton mass ratio
-mnmp = 1.00137841887
-
-
-Molar_n = PhysicalQuantityInteractive(1.00866491578E-3 , 'kg/mol')
-Molar_n.__doc__ = """neutron molar mass  """
-
-
-lambda_C_n = PhysicalQuantityInteractive(1.319590898E-15 , 'm')
-lambda_C_n.__doc__ = """neutron Compton wavelength"""
-
-
-un = PhysicalQuantityInteractive(-0.96623640E-26 , 'J/T')
-un.__doc__ = """neutron magnetic moment """
-
-# neutron magnetic moment to Bohr magneton ratio
-unuB = -1.04187563E-3
-
-# neutron magnetic moment to nuclear magneton ratio
-unuN = -1.91304272
-
-# neutron g-factor
-g_n = -3.82608545
-
-# neutron-electron magnetic moment ratio
-unue = 1.04066882E-3
-
-# neutron-proton magnetic moment ratio
-unup = -0.68497934
-
-# neutron to shielded proton magnetic moment ratio (H2O, sphere, 25  C)
-unusp = -0.68499694
-
-
-gamma_n = PhysicalQuantityInteractive(1.83247188E8 , '1/(s*T)')
-gamma_n.__doc__ = """neutron gyromagnetic ratio """
-
-# Deuteron, d
-#-------------------------------------------------------------------------
-
-m_d = PhysicalQuantityInteractive(3.34358309E-27 , 'kg')
-m_d.__doc__ = """deuteron mass """
-
-
-mu_d = PhysicalQuantityInteractive(2.01355321271 , 'amu')
-mu_d.__doc__ = """deuteron mass (deuteron relative atomic mass times amu)  """
-
-
-mdc2_J = PhysicalQuantityInteractive(3.00506262E-10 , 'J')
-mdc2_J.__doc__ = """deuteron mass energy equivalent """
-
-
-mdc2_eV = PhysicalQuantityInteractive(1875.612762 , 'MeV')
-mdc2_eV.__doc__ = """deuteron mass energy equivalent in MeV  """
-
-# deuteron-electron mass ratio
-mdme = 3670.4829550
-
-# deuteron-proton mass ratio
-mdmp = 1.99900750083
-
-
-Molar_d = PhysicalQuantityInteractive(2.01355321271E-3 , 'kg/mol')
-Molar_d.__doc__ = """deuteron molar mass """
-
-
-ud = PhysicalQuantityInteractive(0.433073457E-26 , 'J/T')
-ud.__doc__ = """deuteron magnetic moment  """
-
-# deuteron magnetic moment to Bohr magneton ratio
-uduB = 0.4669754556E-3
-
-# deuteron magnetic moment to nuclear magneton ratio
-uduN = 0.8574382284
-
-# deuteron-electron magnetic moment ratio
-udue = -4.664345537E-4
-
-# deuteron-proton magnetic moment ratio
-udup = 0.3070122083
-
-# deuteron-neutron magnetic moment ratio
-udun = -0.44820652
-
-# Helion, h
-#-------------------------------------------------------------------------
-
-m_h = PhysicalQuantityInteractive(5.00641174E-27 , 'kg')
-m_h.__doc__ = """helion mass """
-
-
-mu_h = PhysicalQuantityInteractive(3.01493223469 , 'amu')
-mu_h.__doc__ = """helion mass (helion relative atomic mass times amu)  """
-
-
-mhc2_J = PhysicalQuantityInteractive(4.49953848E-10 , 'J')
-mhc2_J.__doc__ = """helion mass energy equivalent """
-
-mhc2_MeV = PhysicalQuantityInteractive(2808.39132 , 'MeV')
-mhc2_MeV.__doc__ = """helion mass energy equivalent in MeV """
-
-# helion-electron mass ratio
-mhme = 5495.885238
-
-# helion-proton mass ratio
-mhmp = 2.99315265850
-
-
-Molar_h = PhysicalQuantityInteractive(3.01493223469E-3 , 'kg/mol')
-Molar_h.__doc__ = """helion molar mass """
-
-
-ush = PhysicalQuantityInteractive(-1.074552967E-26 , 'J/T')
-ush.__doc__ = """shielded helion magnetic moment (gas, sphere, 25  C)"""
-
-# shielded helion magnetic moment to Bohr magneton ratio
-ushuB = -1.158671474E-3
-
-# shielded helion magnetic moment to nuclear magneton ratio
-ushuN = -2.127497718
-
-# shielded helion to proton magnetic moment ratio  (gas, sphere, 25  C)
-ushup = -0.761766563
-
-# shielded helion to shielded proton magnetic moment ratio  (gas/H2O, spheres, 25  C)
-ushusp = -0.7617861313
-
-
-gamma_h = PhysicalQuantityInteractive(2.037894764E8 , '1/(s*T)')
-gamma_h.__doc__ = """shielded helion gyromagnetic  (gas, sphere, 25  C) """
-
-# Alpha particle,
-#-------------------------------------------------------------------------
-
-m_alpha = PhysicalQuantityInteractive(6.64465598E-27 , 'kg')
-m_alpha.__doc__ = """alpha particle mass  """
-
-mu_alpha = PhysicalQuantityInteractive(4.0015061747 , 'amu')
-mu_alpha.__doc__ = """alpha particle mass (alpha particle relative atomic mass times amu) """
-
-
-malphac2_J = PhysicalQuantityInteractive(5.97191897E-10 , 'J')
-malphac2_J.__doc__ = """alpha particle mass energy equivalent  """
-
-
-malphac2_MeV = PhysicalQuantityInteractive(3727.37904 , 'MeV')
-malphac2_MeV.__doc__ = """alpha particle mass energy equivalent in MeV  """
-
-# alpha particle to electron mass ratio
-malphame = 7294.299508
-
-# alpha particle to proton mass ratio
-malphamp = 3.9725996846
-
-
-Molar_alpha = PhysicalQuantityInteractive(4.0015061747E-3 , 'kg/mol')
-Molar_alpha.__doc__ = """alpha particle molar mass"""
-
-# PHYSICO-CHEMICAL
-#-------------------------------------------------------------------------
-
-N_A = PhysicalQuantityInteractive(6.02214199E23 , '1/mol')
-N_A.__doc__ = """Avogadro constant  """
-L = PhysicalQuantityInteractive(6.02214199E23 , '1/mol')
-
-
-m_u = PhysicalQuantityInteractive(1.66053873E-27 , 'kg')
-m_u.__doc__ = """atomic mass constant mu = 112m(12C) = 1 u = 10E-3 kg mol-1/NA"""
-# atomic mass constant mu = 112m(12C) = 1 u = 10E-3 kg mol-1/NA
-amu = m_u
-
-
-muc2_J = PhysicalQuantityInteractive(1.49241778E-10 , 'J')
-muc2_J.__doc__ = """energy equivalent of the atomic mass constant"""
-
-
-muc2_MeV = PhysicalQuantityInteractive(931.494013 , 'MeV')
-muc2_MeV.__doc__ = """energy equivalent of the atomic mass constant in MeV """
-
-
-F = PhysicalQuantityInteractive(96485.3415 , 'C/mol')
-F.__doc__ = """Faraday constant"""
-
-
-N_Ah = PhysicalQuantityInteractive(3.990312689E-10 , 'J*s/mol')
-N_Ah.__doc__ = """molar Planck constant   """
-
-
-R = PhysicalQuantityInteractive(8.314472 , 'J/(mol*K)')
-R.__doc__ = """molar gas constant  """
-
-
-k_J = PhysicalQuantityInteractive(1.3806503E-23 , 'J/K')
-k_J.__doc__ = """Boltzmann constant """
-
-
-k_eV = PhysicalQuantityInteractive(8.617342E-5 , 'eV/K')
-k_eV.__doc__ = """Boltzmann constant in eV """
-
-
-n_0 = PhysicalQuantityInteractive(2.6867775E25 , '1/m**3')
-n_0.__doc__ = """Loschmidt constant  NA/Vm """
-
-
-Vm_1 = PhysicalQuantityInteractive(22.413996E-3 , 'm**3/mol')
-Vm_1.__doc__ = """molar volume of ideal gas RT/p   T = 273.15 K, p = 101.325 kPa """
-
-Vm_2 = PhysicalQuantityInteractive(22.710981E-3 , 'm**3/mol')
-Vm_2.__doc__ = """molar volume of ideal gas RT/p   T = 273.15 K, p = 100 kPa  """
-
-# Sackur-Tetrode constant (absolute entropy constant) 52 + ln_(2 mukT1/h2)3/2kT1/p0
-# T1 = 1 K, p0 = 100 kPa
-S_0R_1 = -1.1517048
-# T1 = 1 K, p0 = 101.325 kPa
-S_0R_2 = -1.1648678
-
-
-sigma = PhysicalQuantityInteractive(5.670400E-8 , 'W/(m**2*K**4)')
-sigma.__doc__ = """Stefan-Boltzmann constant """
-
-
-c_1 = PhysicalQuantityInteractive(3.74177107E-16 , 'W*m**2')
-c_1.__doc__ = """first radiation constant"""
-
-
-c_1L = PhysicalQuantityInteractive(1.191042722E-16 , 'W*m**2/sr')
-c_1L.__doc__ = """first radiation constant for spectral radiance"""
-
-
-c_2 = PhysicalQuantityInteractive(1.4387752E-2 , 'm*K')
-c_2.__doc__ = """second radiation constant"""
-
-
-b = PhysicalQuantityInteractive(2.8977686E-3 , 'm*K')
-b.__doc__ = """Wien displacement law constant b =  maxT = c2/4.965 114231... """
-

IPython/deathrow/ipy_defaults.py

@@ -1,62 +0,0 b''
-""" Set default options for IPython.
-
-Just import this module to get reasonable defaults for everything.
-
-These configurations used to be performed in ipythonrc (or ipythonrc.ini).
-Therefore importing this in your config files makes ipython basically
-ignore your ipythonrc. This is *not* imported by default, you need to import
-this manually in one of your config files.
-
-You can further override these defaults in e.g. your ipy_user_config.py,
-ipy_profile_PROFILENAME etc.
-
-"""
-
-import IPython.utils.rlineimpl as readline
-from IPython.core import ipapi
-ip = ipapi.get()
-
-o = ip.options
-
-o.colors = "Linux"
-o.color_info=1
-o.confirm_exit=1
-o.pprint=1
-o.multi_line_specials=1
-o.xmode="Context"
-
-
-o.prompt_in1='In [\#]: '
-o.prompt_in2 ='   .\D.: '
-o.prompt_out = 'Out[\#]: '
-o.prompts_pad_left=1
-
-o.autoindent = 1
-
-o.readline_remove_delims="-/~"
-o.readline_merge_completions=1
-
-o.readline = 1
-
-rlopts = """\
-tab: complete
-"\C-l": possible-completions
-set show-all-if-ambiguous on
-"\C-o": tab-insert
-"\M-i": "    "
-"\M-o": "\d\d\d\d"
-"\M-I": "\d\d\d\d"
-"\C-r": reverse-search-history
-"\C-s": forward-search-history
-"\C-p": history-search-backward
-"\C-n": history-search-forward
-"\e[A": history-search-backward
-"\e[B": history-search-forward
-"\C-k": kill-line
-"\C-u": unix-line-discard"""
-
-if readline.have_readline:
-    for cmd in rlopts.split('\n'):
-        readline.parse_and_bind(cmd)
-
-

IPython/deathrow/ipy_kitcfg.py

@@ -1,80 +0,0 b''
-import os,sys
-
-import ipy_rehashdir,glob
-from ipy_rehashdir import selflaunch, PyLauncher
-
-def pylaunchers():
-    """Create launchers for python scripts in cwd and store them in alias table
-    
-    This is useful if you want to invoke .py scripts from ipykit session,
-    just adding .py files in PATH does not work without file association.
-    
-    .ipy files will be run like macros.
-    
-    """
-    fs = glob.glob('*.py') + glob.glob('*.ipy')
-    for f in fs:
-        l = PyLauncher(f)
-        n = os.path.splitext(f)[0]
-        ip.define_alias(n, l)
-        ip.magic('store '+n)
-
-
-def exta_imports():
-    # add some modules that you'd want to be bundled in the ipykit
-    # library zip file here. Do this if you get ImportErrors from scripts you
-    # try to launch with 'py' or pylaunchers. In theory you could include
-    # the whole stdlib here for full script coverage
-    
-    # note that this is never run, it's just here for py2exe
-    import distutils.dir_util
-  
-def kitroot():
-    return os.environ.get('IPYKITROOT', None)
-    
-def main():
-
-    if not kitroot():
-        print "Can't configure ipykit, IPYKITROOT should be set."
-        return
-        
-    os.environ["PATH"] = os.environ["PATH"] + ";" + kitroot() + "\\bin;"
-    ip.push("pylaunchers")
-    cmds = ip.db.get('syscmdlist', None)
-    if cmds is None:
-        ip.magic('rehashx')
-        cmds = ip.db.get('syscmdlist', [])
-    #print cmds
-    if 'sc1' in cmds:
-        print "Default editor: Sc1"
-        import ipy_editors
-        ipy_editors.scite('sc1')
-    
-    # for icp, imv, imkdir, etc.
-    import ipy_fsops
-
-greeting = """\n\n === Welcome to ipykit ===
-
-%quickref - learn quickly about IPython.
-
-"""
-    
-def ipython_firstrun(ip):
-
-    print "First run of ipykit - configuring"
-
-    ip.define_alias('py',selflaunch)
-    ip.define_alias('d','dir /w /og /on')
-    ip.magic('store py')
-    ip.magic('store d')
-    
-    bins = kitroot() +'/bin'
-
-    print greeting
-        
-def init_ipython(ipy):
-    global ip
-    ip = ipy
-    main()
-
-

IPython/deathrow/ipy_legacy.py

@@ -1,62 +0,0 b''
-""" Legacy stuff
-
-Various stuff that are there for historical / familiarity reasons.
-
-This is automatically imported by default profile, though not other profiles
-(e.g. 'sh' profile).
-
-Stuff that is considered obsolete / redundant is gradually moved here.
-
-"""
-
-from IPython.core import ipapi
-ip = ipapi.get()
-
-import os,sys
-
-from IPython.utils.genutils import *
-
-# use rehashx
-
-def magic_rehash(self, parameter_s = ''):
-    """Update the alias table with all entries in $PATH.
-
-    This version does no checks on execute permissions or whether the
-    contents of $PATH are truly files (instead of directories or something
-    else).  For such a safer (but slower) version, use %rehashx."""
-
-    # This function (and rehashx) manipulate the alias_table directly
-    # rather than calling magic_alias, for speed reasons.  A rehash on a
-    # typical Linux box involves several thousand entries, so efficiency
-    # here is a top concern.
-
-    path = filter(os.path.isdir,os.environ.get('PATH','').split(os.pathsep))
-    alias_table = self.shell.alias_table
-    for pdir in path:
-        for ff in os.listdir(pdir):
-            # each entry in the alias table must be (N,name), where
-            # N is the number of positional arguments of the alias.
-            alias_table[ff] = (0,ff)
-    # Make sure the alias table doesn't contain keywords or builtins
-    self.shell.alias_table_validate()
-    # Call again init_auto_alias() so we get 'rm -i' and other modified
-    # aliases since %rehash will probably clobber them
-    self.shell.init_auto_alias()
-
-ip.define_magic("rehash", magic_rehash)
-
-# Exit
-def magic_Quit(self, parameter_s=''):
-    """Exit IPython without confirmation (like %Exit)."""
-
-    self.shell.ask_exit()
-
-ip.define_magic("Quit", magic_Quit)
-
-
-# make it autocallable fn if you really need it
-def magic_p(self, parameter_s=''):
-    """Just a short alias for Python's 'print'."""
-    exec 'print ' + parameter_s in self.shell.user_ns
-
-ip.define_magic("p", magic_p)

IPython/deathrow/ipy_p4.py

@@ -1,47 +0,0 b''
-# -*- coding: utf-8 -*-
-"""
-Add %p4 magic for pythonic p4 (Perforce) usage.
-"""
-
-from IPython.core import ipapi
-ip = ipapi.get()
-
-import os,sys,marshal
-
-import ipy_stock_completers
-
-def p4_f(self, parameter_s=''):
-    cmd = 'p4 -G ' + parameter_s
-    fobj = os.popen(cmd)
-    out = []
-    while 1:
-        try:
-            out.append(marshal.load(fobj))
-        except EOFError:
-            break
-        
-    return out
-
-def p4d(fname):
-    return os.popen('p4 where ' + fname).read().split()[0]
-    
-ip.push("p4d")
-
-ip.define_magic('p4', p4_f)
-
-p4_commands = """\
-add admin annotate branch branches change changes changelist
-changelists client clients counter counters delete depot depots
-describe diff diff2 dirs edit filelog files fix fixes flush fstat
-group groups have help info integrate integrated job jobs jobspec
-label labels labelsync lock logger login logout monitor obliterate
-opened passwd print protect rename reopen resolve resolved revert
-review reviews set submit sync tag tickets triggers typemap unlock
-user users verify workspace workspaces where"""
-    
-def p4_completer(self,event):
-    return ipy_stock_completers.vcs_completer(p4_commands, event)
-
-ip.set_hook('complete_command', p4_completer, str_key = '%p4')
-ip.set_hook('complete_command', p4_completer, str_key = 'p4')
-

IPython/deathrow/ipy_profile_none.py

@@ -1,4 +0,0 b''
-""" Config file for 'default' profile """
-
-# get various stuff that are there for historical / familiarity reasons
-import ipy_legacy
  No newline at end of file

IPython/deathrow/ipy_profile_numpy.py

@@ -1,24 +0,0 b''
-""" IPython 'numpy' profile, to preload NumPy.
-
-This profile loads the math/cmath modules as well as all of numpy.
-
-It exposes numpy via the 'np' shorthand as well for convenience.
-"""
-
-from IPython.core import ipapi
-import ipy_defaults
-
-def main():
-    ip = ipapi.get()
-
-    try:
-        ip.ex("import math,cmath")
-        ip.ex("import numpy")
-        ip.ex("import numpy as np")
-
-        ip.ex("from numpy import *")
-
-    except ImportError:
-        print "Unable to start NumPy profile, is numpy installed?"
-    
-main()

IPython/deathrow/ipy_profile_scipy.py

@@ -1,29 +0,0 b''
-""" IPython 'scipy' profile, preloads NumPy and SciPy.
-
-This profile loads the math/cmath modules as well as all of numpy and scipy.
-
-It exposes numpy and scipy via the 'np' and 'sp' shorthands as well for
-convenience.
-"""
-
-from IPython.core import ipapi
-import ipy_defaults
-
-def main():
-    ip = ipapi.get()
-
-    try:
-        ip.ex("import math,cmath")
-        ip.ex("import numpy")
-        ip.ex("import scipy")
-
-        ip.ex("import numpy as np")
-        ip.ex("import scipy as sp")
-    
-        ip.ex("from numpy import *")
-        ip.ex("from scipy import *")
-
-    except ImportError:
-        print "Unable to start scipy profile, are numpy and scipy installed?"
-    
-main()

IPython/deathrow/ipy_profile_sh.py

@@ -1,268 +0,0 b''
-"""Shell mode for IPython.
-
-Start ipython in shell mode by invoking "ipython -p sh"
-
-(the old version, "ipython -p pysh" still works but this is the more "modern"
-shell mode and is recommended for users who don't care about pysh-mode
-compatibility)
-"""
-
-from IPython.core import ipapi
-from IPython.core.error import TryNext
-import os,re,textwrap
-
-# The import below effectively obsoletes your old-style ipythonrc[.ini],
-# so consider yourself warned!
-
-import ipy_defaults
-
-def main():
-    ip = ipapi.get()
-    o = ip.options
-    # autocall to "full" mode (smart mode is default, I like full mode)
-
-    o.autocall = 2
-
-    # Jason Orendorff's path class is handy to have in user namespace
-    # if you are doing shell-like stuff
-    try:
-        ip.ex("from IPython.external.path import path" )
-    except ImportError:
-        pass
-
-    # beefed up %env is handy in shell mode
-    import envpersist
-
-    # To see where mycmd resides (in path/aliases), do %which mycmd
-    import ipy_which
-
-    # tab completers for hg, svn, ...
-    import ipy_app_completers
-
-    # To make executables foo and bar in mybin usable without PATH change, do:
-    # %rehashdir c:/mybin
-    # %store foo
-    # %store bar
-    import ipy_rehashdir
-
-    # does not work without subprocess module!
-    #import ipy_signals
-
-    ip.ex('import os')
-    ip.ex("def up(): os.chdir('..')")
-    ip.user_ns['LA'] = LastArgFinder()
-
-    # You can assign to _prompt_title variable
-    # to provide some extra information for prompt
-    # (e.g. the current mode, host/username...)
-
-    ip.user_ns['_prompt_title'] = ''
-
-    # Nice prompt
-    o.prompt_in1= r'\C_Green${_prompt_title}\C_LightBlue[\C_LightCyan\Y2\C_LightBlue]\C_Green|\#> '
-    o.prompt_in2= r'\C_Green|\C_LightGreen\D\C_Green> '
-    o.prompt_out= '<\#> '
-
-    from IPython.core import release
-
-    import sys
-    # Non-chatty banner
-    o.banner = "IPython %s   [on Py %s]\n" % (release.version,sys.version.split(None,1)[0])
-
-
-    ip.default_option('cd','-q')
-    ip.default_option('macro', '-r')
-    # If you only rarely want to execute the things you %edit...
-    #ip.default_option('edit','-x')
-
-
-    o.prompts_pad_left="1"
-    # Remove all blank lines in between prompts, like a normal shell.
-    o.separate_in="0"
-    o.separate_out="0"
-    o.separate_out2="0"
-
-    # now alias all syscommands
-
-    db = ip.db
-
-    syscmds = db.get("syscmdlist",[] )
-    if not syscmds:
-        print textwrap.dedent("""
-        System command list not initialized, probably the first run...
-        running %rehashx to refresh the command list. Run %rehashx
-        again to refresh command list (after installing new software etc.)
-        """)
-        ip.magic('rehashx')
-        syscmds = db.get("syscmdlist")
-
-    # lowcase aliases on win32 only
-    if os.name == 'posix':
-        mapper = lambda s:s
-    else:
-        def mapper(s): return s.lower()
-
-    for cmd in syscmds:
-        # print "sys",cmd #dbg
-        noext, ext = os.path.splitext(cmd)
-        if ext.lower() == '.exe':
-            cmd = noext
-
-        key = mapper(cmd)
-        if key not in ip.alias_manager.alias_table:
-            # Dots will be removed from alias names, since ipython
-            # assumes names with dots to be python code
-
-            ip.define_alias(key.replace('.',''), cmd)
-
-    # win32 is crippled w/o cygwin, try to help it a little bit
-    if sys.platform == 'win32':
-        if 'cygwin' in os.environ['PATH'].lower():
-            # use the colors of cygwin ls (recommended)
-            ip.define_alias('d', 'ls -F --color=auto')
-        else:
-            # get icp, imv, imkdir, igrep, irm,...
-            ip.load('ipy_fsops')
-
-            # and the next best thing to real 'ls -F'
-            ip.define_alias('d','dir /w /og /on')
-
-    ip.set_hook('input_prefilter', slash_prefilter_f)
-    extend_shell_behavior(ip)
-
-class LastArgFinder:
-    """ Allow $LA to work as "last argument of previous command", like $! in bash
-
-    To call this in normal IPython code, do LA()
-    """
-    def __call__(self, hist_idx = None):
-        ip = ipapi.get()
-        if hist_idx is None:
-            return str(self)
-        return ip.input_hist_raw[hist_idx].strip().split()[-1]
-    def __str__(self):
-        ip = ipapi.get()
-        for cmd in reversed(ip.input_hist_raw):
-            parts = cmd.strip().split()
-            if len(parts) < 2 or parts[-1] in ['$LA', 'LA()']:
-                continue
-            return parts[-1]
-        return ""
-
-def slash_prefilter_f(self,line):
-    """ ./foo, ~/foo and /bin/foo now run foo as system command
-
-    Removes the need for doing !./foo, !~/foo or !/bin/foo
-    """
-    from IPython.utils import genutils
-    if re.match('(?:[.~]|/[a-zA-Z_0-9]+)/', line):
-        return "get_ipython().system(" + genutils.make_quoted_expr(line)+")"
-    raise TryNext
-
-# XXX You do not need to understand the next function!
-# This should probably be moved out of profile
-
-def extend_shell_behavior(ip):
-
-    # Instead of making signature a global variable tie it to IPSHELL.
-    # In future if it is required to distinguish between different
-    # shells we can assign a signature per shell basis
-    ip.__sig__ = 0xa005
-    # mark the IPSHELL with this signature
-    ip.user_ns['__builtins__'].__dict__['__sig__'] = ip.__sig__
-
-    from IPython.external.Itpl import ItplNS
-    from IPython.utils.genutils import shell
-    # utility to expand user variables via Itpl
-    # xxx do something sensible with depth?
-    ip.var_expand = lambda cmd, lvars=None, depth=2: \
-        str(ItplNS(cmd, ip.user_ns, get_locals()))
-
-    def get_locals():
-        """ Substituting a variable through Itpl deep inside the IPSHELL stack
-            requires the knowledge of all the variables in scope upto the last
-            IPSHELL frame. This routine simply merges all the local variables
-            on the IPSHELL stack without worrying about their scope rules
-        """
-        import sys
-        # note lambda expression constitues a function call
-        # hence fno should be incremented by one
-        getsig = lambda fno: sys._getframe(fno+1).f_globals \
-                             ['__builtins__'].__dict__['__sig__']
-        getlvars = lambda fno: sys._getframe(fno+1).f_locals
-        # trackback until we enter the IPSHELL
-        frame_no = 1
-        sig = ip.__sig__
-        fsig = ~sig
-        while fsig != sig :
-            try:
-                fsig = getsig(frame_no)
-            except (AttributeError, KeyError):
-                frame_no += 1
-            except ValueError:
-                # stack is depleted
-                # call did not originate from IPSHELL
-                return {}
-        first_frame = frame_no
-        # walk further back until we exit from IPSHELL or deplete stack
-        try:
-            while(sig == getsig(frame_no+1)):
-                frame_no += 1
-        except (AttributeError, KeyError, ValueError):
-            pass
-        # merge the locals from top down hence overriding
-        # any re-definitions of variables, functions etc.
-        lvars = {}
-        for fno in range(frame_no, first_frame-1, -1):
-            lvars.update(getlvars(fno))
-        #print '\n'*5, first_frame, frame_no, '\n', lvars, '\n'*5 #dbg
-        return lvars
-
-    def _runlines(lines):
-        """Run a string of one or more lines of source.
-
-        This method is capable of running a string containing multiple source
-        lines, as if they had been entered at the IPython prompt.  Since it
-        exposes IPython's processing machinery, the given strings can contain
-        magic calls (%magic), special shell access (!cmd), etc."""
-
-        # We must start with a clean buffer, in case this is run from an
-        # interactive IPython session (via a magic, for example).
-        ip.resetbuffer()
-        lines = lines.split('\n')
-        more = 0
-        command = ''
-        for line in lines:
-            # skip blank lines so we don't mess up the prompt counter, but do
-            # NOT skip even a blank line if we are in a code block (more is
-            # true)
-            # if command is not empty trim the line
-            if command != '' :
-                line = line.strip()
-            # add the broken line to the command
-            if line and line[-1] == '\\' :
-                command += line[0:-1] + ' '
-                more = True
-                continue
-            else :
-                # add the last (current) line to the command
-                command += line
-                if command or more:
-                    # push to raw history, so hist line numbers stay in sync
-                    ip.input_hist_raw.append("# " + command + "\n")
-
-                    more = ip.push_line(ip.prefilter(command,more))
-                    command = ''
-                    # IPython's runsource returns None if there was an error
-                    # compiling the code.  This allows us to stop processing right
-                    # away, so the user gets the error message at the right place.
-                    if more is None:
-                        break
-        # final newline in case the input didn't have it, so that the code
-        # actually does get executed
-        if more:
-            ip.push_line('\n')
-
-    ip.runlines = _runlines
-
-main()

IPython/deathrow/ipy_profile_zope.py

@@ -1,324 +0,0 b''
-# -*- coding: utf-8 -*-
-""" An ipython profile for zope and plone.
-
-Some ideas stolen from http://www.tomster.org.
-
-
-Authors
--------
-- Stefan Eletzhofer <[e-mail]>
-"""
-
-# File: ipy_profile_zope.py
-#
-# Copyright (c) InQuant GmbH
-#
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-
-from IPython.core import ipapi
-from IPython.core import release
-from types import StringType
-import sys
-import os
-import textwrap
-
-sys_oldstdin  = sys.stdin
-
-# The import below effectively obsoletes your old-style ipythonrc[.ini],
-# so consider yourself warned!
-# import ipy_defaults
-
-_marker = []
-def shasattr(obj, attr, acquire=False):
-    """ See Archetypes/utils.py
-    """
-    if not acquire:
-        obj = obj.aq_base
-    return getattr(obj, attr, _marker) is not _marker
-
-class ZopeDebug(object):
-    def __init__(self):
-
-        self.instancehome = os.environ.get( "INSTANCE_HOME" )
-
-        configfile = os.environ.get( "CONFIG_FILE" )
-        if configfile is None and self.instancehome is not None:
-            configfile = os.path.join( self.instancehome, "etc", "zope.conf" )
-
-        if configfile is None:
-            raise RuntimeError( "CONFIG_FILE env not set" )
-
-        print "CONFIG_FILE=", configfile
-        print "INSTANCE_HOME=", self.instancehome
-
-        self.configfile = configfile
-
-        try:
-            from Zope2 import configure
-        except ImportError:
-            from Zope import configure
-
-        configure( configfile )
-
-        try:
-            import Zope2
-            app = Zope2.app()
-        except ImportError:
-            import Zope
-            app = Zope.app()
-
-        from Testing.makerequest import makerequest
-        self.app = makerequest( app )
-
-        try:
-            self._make_permissive()
-            print "Permissive security installed"
-        except:
-            print "Permissive security NOT installed"
-
-        self._pwd = self.portal or self.app
-
-        try:
-            from zope.component import getSiteManager
-            from zope.component import getGlobalSiteManager
-            from zope.app.component.hooks import setSite
-
-            if self.portal is not None:
-                setSite( self.portal )
-
-                gsm = getGlobalSiteManager()
-                sm = getSiteManager()
-
-                if sm is gsm:
-                    print "ERROR SETTING SITE!"
-        except:
-            pass
-
-
-    @property
-    def utils(self):
-        class Utils(object):
-            commit = self.commit
-            sync = self.sync
-            objectInfo = self.objectInfo
-            ls = self.ls
-            pwd = self.pwd
-            cd = self.cd
-            su = self.su
-            getCatalogInfo = self.getCatalogInfo
-
-            @property
-            def cwd(self):
-                return self.pwd()
-
-        return Utils()
-
-    @property
-    def namespace(self):
-        return dict( utils=self.utils, app=self.app, portal=self.portal )
-
-    @property
-    def portal(self):
-        portals = self.app.objectValues( "Plone Site" )
-        if len(portals):
-            return portals[0]
-        else:
-            raise KeyError( "No Plone Site found.")
-
-    def pwd(self):
-        return self._pwd
-
-    def _make_permissive(self):
-        """
-        Make a permissive security manager with all rights. Hell,
-        we're developers, aren't we? Security is for whimps. :)
-        """
-        from Products.CMFCore.tests.base.security import PermissiveSecurityPolicy
-        import AccessControl
-        from AccessControl.SecurityManagement import newSecurityManager
-        from AccessControl.SecurityManager import setSecurityPolicy
-
-        _policy = PermissiveSecurityPolicy()
-        self.oldpolicy = setSecurityPolicy(_policy)
-        newSecurityManager(None, AccessControl.User.system)
-
-    def su(self, username):
-        """ Change to named user.
-        """
-        # TODO Make it easy to change back to permissive security.
-        user = self.portal.acl_users.getUser(username)
-        if not user:
-            print "Can't find %s in %s" % (username, self.portal.acl_users)
-            return
-
-        from AccessControl import ZopeSecurityPolicy
-        import AccessControl
-        from AccessControl.SecurityManagement import newSecurityManager, getSecurityManager
-        from AccessControl.SecurityManager import setSecurityPolicy
-
-        _policy = ZopeSecurityPolicy
-        self.oldpolicy = setSecurityPolicy(_policy)
-        wrapped_user = user.__of__(self.portal.acl_users)
-        newSecurityManager(None, user)
-        print 'User changed.'
-        return getSecurityManager().getUser()
-
-    def getCatalogInfo(self, obj=None, catalog='portal_catalog', query=None, sort_on='created', sort_order='reverse' ):
-        """ Inspect portal_catalog. Pass an object or object id for a
-        default query on that object, or pass an explicit query.
-        """
-        if obj and query:
-            print "Ignoring %s, using query." % obj
-
-        catalog = self.portal.get(catalog)
-        if not catalog:
-            return 'No catalog'
-
-        indexes = catalog._catalog.indexes
-        if not query:
-            if type(obj) is StringType:
-                cwd = self.pwd()
-                obj = cwd.unrestrictedTraverse( obj )
-            # If the default in the signature is mutable, its value will
-            # persist across invocations.
-            query = {}
-            if indexes.get('path'):
-                from string import join
-                path = join(obj.getPhysicalPath(), '/')
-                query.update({'path': path})
-            if indexes.get('getID'):
-                query.update({'getID': obj.id, })
-            if indexes.get('UID') and shasattr(obj, 'UID'):
-                query.update({'UID': obj.UID(), })
-        if indexes.get(sort_on):
-            query.update({'sort_on': sort_on, 'sort_order': sort_order})
-        if not query:
-            return 'Empty query'
-        results = catalog(**query)
-
-        result_info = []
-        for r in results:
-            rid = r.getRID()
-            if rid:
-                result_info.append(
-                        {'path': catalog.getpath(rid),
-                        'metadata': catalog.getMetadataForRID(rid),
-                        'indexes': catalog.getIndexDataForRID(rid), }
-                        )
-            else:
-                result_info.append({'missing': rid})
-
-        if len(result_info) == 1:
-            return result_info[0]
-        return result_info
-
-    def commit(self):
-        """
-        Commit the transaction.
-        """
-        try:
-            import transaction
-            transaction.get().commit()
-        except ImportError:
-            get_transaction().commit()
-
-    def sync(self):
-        """
-        Sync the app's view of the zodb.
-        """
-        self.app._p_jar.sync()
-
-    def objectInfo( self, o ):
-        """
-        Return a descriptive string of an object
-        """
-        Title = ""
-        t = getattr( o, 'Title', None )
-        if t:
-            Title = t()
-        return {'id': o.getId(),
-                'Title': Title,
-                'portal_type': getattr( o, 'portal_type', o.meta_type),
-                'folderish': o.isPrincipiaFolderish
-                }
-
-    def cd( self, path ):
-        """
-        Change current dir to a specific folder.
-
-         cd( ".." )
-         cd( "/plone/Members/admin" )
-         cd( portal.Members.admin )
-         etc.
-        """
-        if type(path) is not StringType:
-            path = '/'.join(path.getPhysicalPath())
-        cwd = self.pwd()
-        x = cwd.unrestrictedTraverse( path )
-        if x is None:
-            raise KeyError( "Can't cd to %s" % path )
-
-        print "%s -> %s" % ( self.pwd().getId(), x.getId() )
-        self._pwd = x
-
-    def ls( self, x=None ):
-        """
-        List object(s)
-        """
-        if type(x) is StringType:
-            cwd = self.pwd()
-            x = cwd.unrestrictedTraverse( x )
-        if x is None:
-            x = self.pwd()
-        if x.isPrincipiaFolderish:
-            return [self.objectInfo(o) for id, o in x.objectItems()]
-        else:
-            return self.objectInfo( x )
-
-zope_debug = None
-
-def ipy_set_trace():
-    from IPython.core import debugger
-    debugger.Pdb().set_trace()
-
-def main():
-    global zope_debug
-    ip = ipapi.get()
-    o = ip.options
-    # autocall to "full" mode (smart mode is default, I like full mode)
-
-    SOFTWARE_HOME = os.environ.get( "SOFTWARE_HOME" )
-    sys.path.append( SOFTWARE_HOME )
-    print "SOFTWARE_HOME=%s\n" % SOFTWARE_HOME
-
-    zope_debug = ZopeDebug()
-
-    # <HACK ALERT>
-    import pdb;
-    pdb.set_trace = ipy_set_trace
-    # </HACK ALERT>
-
-    # I like my banner minimal.
-    o.banner = "ZOPE Py %s IPy %s\n" % (sys.version.split('\n')[0],release.version)
-
-    print textwrap.dedent("""\
-        ZOPE mode iPython shell.
-
-          Bound names:
-           app
-           portal
-           utils.{ %s }
-
-        Uses the $SOFTWARE_HOME and $CONFIG_FILE environment
-        variables.
-        """ % ( ",".join([ x for x in dir(zope_debug.utils) if not x.startswith("_") ] ) ) )
-
-
-    sys.stdin  = sys_oldstdin
-    ip.user_ns.update( zope_debug.namespace )
-
-
-main()
-# vim: set ft=python ts=4 sw=4 expandtab :

IPython/deathrow/ipy_traits_completer.py

@@ -1,219 +0,0 b''
-"""Traits-aware tab completion.
-
-This module provides a custom tab-completer that intelligently hides the names
-that the enthought.traits library (http://code.enthought.com/traits)
-automatically adds to all objects that inherit from its base HasTraits class.
-
-
-Activation
-==========
-
-To use this, put in your ~/.ipython/ipy_user_conf.py file:
-
-    from ipy_traits_completer import activate
-    activate([complete_threshold])
-
-The optional complete_threshold argument is the minimal length of text you need
-to type for tab-completion to list names that are automatically generated by
-traits.  The default value is 3.  Note that at runtime, you can change this
-value simply by doing:
-
-    import ipy_traits_completer
-    ipy_traits_completer.COMPLETE_THRESHOLD = 4
-
-
-Usage
-=====
-
-The system works as follows.  If t is an empty object that HasTraits, then
-(assuming the threshold is at the default value of 3):
-
-In [7]: t.ed<TAB>
-
-doesn't show anything at all, but:
-
-In [7]: t.edi<TAB>
-t.edit_traits      t.editable_traits
-
-shows these two names that come from traits.  This allows you to complete on
-the traits-specific names by typing at least 3 letters from them (or whatever
-you set your threshold to), but to otherwise not see them in normal completion.
-
-
-Notes
-=====
-
-  - This requires Python 2.4 to work (I use sets).  I don't think anyone is
-    using traits with 2.3 anyway, so that's OK.
-
-  - Imports from enthought.traits are deferred until an object with a class that
-    looks like it subclasses from HasTraits comes along. This test is done by
-    looking at the name of the class and its superclasses.
-"""
-
-#############################################################################
-# IPython imports
-from IPython.core.error import TryNext
-from IPython.core.ipapi import get as ipget
-from IPython.utils.dir2 import dir2
-try:
-    set
-except:
-    from sets import Set as set
-
-#############################################################################
-# Module constants
-
-# The completion threshold
-# This is currently implemented as a module global, since this sytem isn't
-# likely to be modified at runtime by multiple instances.  If needed in the
-# future, we can always make it local to the completer as a function attribute.
-COMPLETE_THRESHOLD = 3
-
-# Set of names that Traits automatically adds to ANY traits-inheriting object.
-# These are the names we'll filter out.
-TRAIT_NAMES = None
-def get_trait_names():
-    global TRAIT_NAMES
-    from enthought.traits.api import HasTraits
-    if TRAIT_NAMES is None:
-        TRAIT_NAMES = set( dir2(HasTraits()) ) - set( dir2(object()) )
-    else:
-        return TRAIT_NAMES
-
-#############################################################################
-# Code begins
-
-def looks_like_isinstance(obj, classname):
-    """ Return True if the object has a class or superclass with the given class
-    name.
-
-    Ignores old-style classes.
-    """
-    from types import InstanceType
-
-    t = type(obj)
-    if t is InstanceType:
-        # Old-style classes.
-        return False
-    elif t.__name__ == classname:
-        return True
-    for klass in t.__mro__:
-        if klass.__name__ == classname:
-            return True
-    return False
-
-def trait_completer(self,event):
-    """A custom IPython tab-completer that is traits-aware.
-
-    It tries to hide the internal traits attributes, and reveal them only when
-    it can reasonably guess that the user really is after one of them.
-    """
-    
-    #print '\nevent is:',event  # dbg
-    symbol_parts = event.symbol.split('.')
-    base = '.'.join(symbol_parts[:-1])
-    #print 'base:',base  # dbg
-
-    oinfo = self._ofind(base)
-    if not oinfo['found']:
-        raise TryNext
-
-    obj = oinfo['obj']
-    # OK, we got the object.  See if it's traits, else punt
-    if not looks_like_isinstance(obj, 'HasTraits'):
-        raise TryNext
-
-    # Defer import until here so as not to require Traits until we get something
-    # that looks like it might be a HasTraits instance.
-    from enthought.traits.api import HasTraits
-    if not isinstance(obj, HasTraits):
-        raise TryNext
-
-    # it's a traits object, don't show the tr* attributes unless the completion
-    # begins with 'tr'
-    attrs = dir2(obj)
-    # Now, filter out the attributes that start with the user's request
-    attr_start = symbol_parts[-1]
-    if attr_start:
-        attrs = [a for a in attrs if a.startswith(attr_start)]
-    
-    # Let's also respect the user's readline_omit__names setting:
-    omit__names = ipget().options.readline_omit__names
-    if omit__names == 1:
-        attrs = [a for a in attrs if not a.startswith('__')]
-    elif omit__names == 2:
-        attrs = [a for a in attrs if not a.startswith('_')]
-
-    #print '\nastart:<%r>' % attr_start  # dbg
-
-    if len(attr_start)<COMPLETE_THRESHOLD:
-        attrs = list(set(attrs) - get_trait_names())
-        
-    # The base of the completion, so we can form the final results list
-    bdot = base+'.'
-
-    tcomp = [bdot+a for a in attrs]
-    #print 'tcomp:',tcomp
-    return tcomp
-
-def activate(complete_threshold = COMPLETE_THRESHOLD):
-    """Activate the Traits completer.
-
-    :Keywords:
-      complete_threshold : int
-        The minimum number of letters that a user must type in order to
-      activate completion of traits-private names."""
-    
-    if not (isinstance(complete_threshold,int) and
-            complete_threshold>0):
-        e='complete_threshold must be a positive integer, not %r'  % \
-           complete_threshold
-        raise ValueError(e)
-
-    # Set the module global
-    global COMPLETE_THRESHOLD
-    COMPLETE_THRESHOLD = complete_threshold
-
-    # Activate the traits aware completer
-    ip = ipget()
-    ip.set_hook('complete_command', trait_completer, re_key = '.*')
-
-
-#############################################################################
-if __name__ == '__main__':
-    # Testing/debugging
-    from enthought.traits.api import HasTraits
-
-    # A sorted list of the names we'll filter out
-    TNL = list(get_trait_names())
-    TNL.sort()
-
-    # Make a few objects for testing
-    class TClean(HasTraits): pass
-    class Bunch(object): pass
-    # A clean traits object
-    t = TClean()
-    # A nested object containing t
-    f = Bunch()
-    f.t = t
-    # And a naked new-style object
-    o = object()
-
-    ip = ipget().IP
-    
-    # A few simplistic tests
-
-    # Reset the threshold to the default, in case the test is running inside an
-    # instance of ipython that changed it
-    import ipy_traits_completer
-    ipy_traits_completer.COMPLETE_THRESHOLD = 3
-
-    assert ip.complete('t.ed') ==[]
-
-    # For some bizarre reason, these fail on the first time I run them, but not
-    # afterwards.  Traits does some really weird stuff at object instantiation
-    # time...
-    ta = ip.complete('t.edi')
-    assert ta == ['t.edit_traits', 't.editable_traits']
-    print 'Tests OK'

IPython/deathrow/ipy_vimserver.py

@@ -1,245 +0,0 b''
-""" Integration with gvim, by Erich Heine
-
-Provides a %vim magic command, and reuses the same vim session. Uses
-unix domain sockets for communication between vim and IPython. ipy.vim is
-available in doc/examples of the IPython distribution.
-
-Slightly touched up email announcement (and description how to use it) by
-Erich Heine is here:
-
-Ive recently been playing with ipython, and like it quite a bit. I did
-however discover a bit of frustration, namely with editor interaction.
-I am a gvim user, and using the command edit on a new file causes
-ipython to try and run that file as soon as the text editor opens
-up. The -x command of course fixes this, but its still a bit annoying,
-switching windows to do a run file, then back to the text
-editor. Being a heavy tab user in gvim, another annoyance is not being
-able to specify weather a new tab is how I choose to open the file.
-
-Not being one to shirk my open source duties (and seeing this as a
-good excuse to poke around ipython internals), Ive created a script
-for having gvim and ipython work very nicely together. Ive attached
-both to this email (hoping of course that the mailing list allows such
-things).
-
-There are 2 files:
-
-ipy_vimserver.py -- this file contains the ipython stuff
-ipy.vim -- this file contains the gvim stuff
-
-In combination they allow for a few functionalities:
-
-#1. the vim magic command. This is a fancy wrapper around the edit
-magic, that allows for a new option, -t, which opens the text in a new
-gvim tab.  Otherwise it works the same as edit -x. (it internally
-calls edit -x). This magic command also juggles vim server management,
-so when it is called when there is not a gvim running, it creates a
-new gvim instance, named after the ipython session name.  Once such a
-gvim instance is running, it will be used for subsequent uses of the
-vim command.
-
-#2. ipython - gvim interaction. Once a file has been opened with the
-vim magic (and a session set up, see below), pressing the F5 key in
-vim will cause the calling ipython instance to execute run
-filename.py. (if you typo like I do, this is very useful)
-
-#3. ipython server - this is a thread wich listens on a unix domain
-socket, and runs commands sent to that socket.
-
-Note, this only works on POSIX systems, that allow for AF_UNIX type
-sockets. It has only been tested on linux (a fairly recent debian
-testing distro).
-
-To install it put, the ipserver.py in your favorite locaion for
-sourcing ipython scripts. I put the ipy.vim in
-~/.vim/after/ftplugin/python/.
-
-To use (this can be scripted im sure, but i usually have 2 or 3
-ipythons and corresponding gvims open):
-
-import ipy_vimserver
-ipy_vimserver.setup('sessionname')
-
-(Editors note - you can probably add these to your ipy_user_conf.py)
-
-Then use ipython as you normally would, until you need to edit
-something. Instead of edit, use the vim magic.  Thats it!
-
-"""
-
-from IPython.core import ipapi
-from IPython.core.error import TryNext
-
-import socket, select
-import os, threading, subprocess
-import re
-
-try:
-    ERRCONDS = select.POLLHUP|select.POLLERR
-except AttributeError:
-    raise ImportError("Vim server not supported on this platform - select "
-                      "missing necessary POLLHUP/POLLERR functionality")
-
-SERVER = None
-ip = ipapi.get()
-
-# this listens to a unix domain socket in a separate thread, so that comms
-# between a vim instance and ipython can happen in a fun and productive way
-class IpyServer(threading.Thread):
-    def __init__(self, sname):
-        super(IpyServer, self).__init__()
-        self.keep_running = True
-        self.__sname = sname
-        self.socket = socket.socket(socket.AF_UNIX)
-        self.poller = select.poll()
-        self.current_conns = dict()
-        self.setDaemon(True)
-
-    def listen(self):
-        self.socket.bind(self.__sname)
-        self.socket.listen(1)
-
-    def __handle_error(self, socket):
-        if socket == self.socket.fileno():
-            self.keep_running = False
-            for a in self.current_conns.values():
-                a.close()
-            return False
-        else:
-            y = self.current_conns[socket]
-            del self.current_conns[socket]
-        y.close()
-        self.poller.unregister(socket)
-
-    def serve_me(self):
-        self.listen()
-        self.poller.register(self.socket,select.POLLIN|ERRCONDS)
-
-        while self.keep_running:
-            try:
-                avail = self.poller.poll(1)
-            except:
-                continue
-
-            if not avail: continue
-
-            for sock, conds in avail:
-                if conds & (ERRCONDS):
-                    if self.__handle_error(sock): continue
-                    else: break
-
-                if sock == self.socket.fileno():
-                    y = self.socket.accept()[0]
-                    self.poller.register(y, select.POLLIN|ERRCONDS)
-                    self.current_conns[y.fileno()] = y
-                else: y = self.current_conns.get(sock)
-
-                self.handle_request(y)
-
-        os.remove(self.__sname)
-
-    run = serve_me
-
-    def stop(self):
-        self.keep_running = False
-
-    def handle_request(self,sock):
-        sock.settimeout(1)
-        while self.keep_running:
-            try:
-                x = sock.recv(4096)
-            except socket.timeout:
-                pass
-            else:
-                break
-        self.do_it(x)
-
-    def do_it(self, data):
-        data = data.split('\n')
-        cmds = list()
-        for line in data:
-            cmds.append(line)
-        ip.runlines(cmds)
-
-
-# try to help ensure that the unix domain socket is cleaned up proper
-def shutdown_server(self):
-    if SERVER:
-        SERVER.stop()
-        SERVER.join(3)
-    raise TryNext
-
-ip.set_hook('shutdown_hook', shutdown_server, 10)
-
-# this fun function exists to make setup easier for all, and makes the
-# vimhook function ready for instance specific communication
-def setup(sessionname='',socketdir=os.path.expanduser('~/.ipython/')):
-    global SERVER
-
-    if sessionname:
-        session = sessionname
-    elif os.environ.get('IPY_SESSION'):
-        session = os.environ.get('IPY_SESSION')
-    else:
-        session = 'IPYS'
-    vimhook.vimserver=session
-    vimhook.ipyserver = os.path.join(socketdir, session)
-    if not SERVER:
-        SERVER = IpyServer(vimhook.ipyserver)
-        SERVER.start()
-
-
-
-# calls gvim, with all ops happening on the correct gvim instance for this
-# ipython instance. it then calls edit -x (since gvim will return right away)
-# things of note: it sets up a special environment, so that the ipy.vim script
-# can connect back to the ipython instance and do fun things, like run the file
-def vimhook(self, fname, line):
-    env = os.environ.copy()
-    vserver = vimhook.vimserver.upper()
-    check = subprocess.Popen('gvim --serverlist', stdout = subprocess.PIPE,
-        shell=True)
-    check.wait()
-    cval = [l for l in check.stdout.readlines() if vserver in l]
-
-    if cval:
-        vimargs = '--remote%s' % (vimhook.extras,)
-    else:
-        vimargs = ''
-    vimhook.extras = ''
-
-    env['IPY_SESSION'] = vimhook.vimserver
-    env['IPY_SERVER'] = vimhook.ipyserver
-
-    if line is None: line = ''
-    else: line = '+' + line
-    vim_cmd = 'gvim --servername %s %s %s %s' % (vimhook.vimserver, vimargs,
-        line, fname)
-    subprocess.call(vim_cmd, env=env, shell=True)
-
-
-#default values to keep it sane...
-vimhook.vimserver = ''
-vimhook.ipyserver = ''
-
-ip.set_hook('editor',vimhook)
-
-# this is set up so more vim specific commands can be added, instead of just
-# the current -t. all thats required is a compiled regex, a call to do_arg(pat)
-# and the logic to deal with the new feature
-newtab = re.compile(r'-t(?:\s|$)')
-def vim(self, argstr):
-    def do_arg(pat, rarg):
-        x = len(pat.findall(argstr))
-        if x:
-            a = pat.sub('',argstr)
-            return rarg, a
-        else: return '', argstr
-
-    t, argstr = do_arg(newtab, '-tab')
-    vimhook.extras = t
-    argstr = 'edit -x ' + argstr
-    ip.magic(argstr)
-
-ip.define_magic('vim', vim)
-

IPython/deathrow/ipython-wx

@@ -1,11 +0,0 b''
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""wxIPython -- An enhanced Interactive Python GUI fonrtend
-This script starts the Wx graphical frontend.
-This is experimental so far.
-Currently it support only ipython0 instance. Will be upgraded to ipython1 one.
-"""
-
-from IPython.gui.wx import wxIPython
-
-wxIPython.main()

IPython/deathrow/ipythonx

@@ -1,11 +0,0 b''
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""IPythonX -- An enhanced Interactive Python
-
-This script starts the Wx graphical frontend. This is experimental so
-far.
-"""
-
-from IPython.frontend.wx import ipythonx
-
-ipythonx.main()

IPython/deathrow/numeric_formats.py

@@ -1,43 +0,0 b''
-# -*- coding: utf-8 -*-
-"""
-Extension for printing Numeric Arrays in flexible ways.
-"""
-
-from Numeric import ArrayType
-
-def num_display(self,arg):
-    """Display method for printing which treats Numeric arrays specially.
-    """
-
-    # Non-numpy variables are printed using the system default
-    if type(arg) != ArrayType:
-        self._display(arg)
-        return
-    # Otherwise, we do work.
-    format = __IPYTHON__.runtime_rc.numarray_print_format
-    print 'NumPy array, format:',format
-    # Here is where all the printing logic needs to be implemented
-    print arg # nothing yet :)
-
-
-def magic_format(self,parameter_s=''):
-    """Specifies format of numerical output.
-
-    This command is similar to Ocave's format command.
-    """
-
-    valid_formats = ['long','short']
-    
-    if parameter_s in valid_formats:
-        self.runtime_rc.numarray_print_format = parameter_s
-        print 'Numeric output format is now:',parameter_s
-    else:
-        print 'Invalid format:',parameter_s
-        print 'Valid formats:',valid_formats
-
-# setup default format
-__IPYTHON__.runtime_rc.numarray_print_format = 'long'
-
-# Bind our new functions to the interpreter
-__IPYTHON__.__class__.magic_format = magic_format
-__IPYTHON__.hooks.display = num_display

IPython/deathrow/numutils.py

@@ -1,302 +0,0 b''
-# -*- coding: utf-8 -*-
-"""
-A set of convenient utilities for numerical work.
-
-Most of this module requires Numerical Python or is meant to be used with it.
-See http://www.pfdubois.com/numpy for details.
-"""
-
-#*****************************************************************************
-#       Copyright (C) 2001-2005 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.
-#*****************************************************************************
-
-__all__ = ['sum_flat','mean_flat','rms_flat','base_repr','binary_repr',
-           'amin','amax','amap','zeros_like','empty_like',
-           'frange','diagonal_matrix','identity',
-           'fromfunction_kw','log2','ispower2',
-           'norm','l1norm','l2norm','exp_safe',
-           'inf','infty','Infinity',
-           'Numeric']
-
-#****************************************************************************
-# required modules
-import __main__
-import math
-import operator
-import sys
-
-import Numeric
-from Numeric import *
-
-#*****************************************************************************
-# Globals
-
-# useful for testing infinities in results of array divisions (which don't
-# raise an exception)
-# Python, LaTeX and Mathematica names.
-inf = infty = Infinity = (array([1])/0.0)[0]
-
-#****************************************************************************
-# function definitions
-exp_safe_MIN = math.log(2.2250738585072014e-308)
-exp_safe_MAX = 1.7976931348623157e+308
-
-def exp_safe(x):
-    """Compute exponentials which safely underflow to zero.
-
-    Slow but convenient to use. Note that NumArray will introduce proper
-    floating point exception handling with access to the underlying
-    hardware."""
-
-    if type(x) is ArrayType:
-        return exp(clip(x,exp_safe_MIN,exp_safe_MAX))
-    else:
-        return math.exp(x)
-
-def amap(fn,*args):
-    """amap(function, sequence[, sequence, ...]) -> array.
-
-    Works like map(), but it returns an array.  This is just a convenient
-    shorthand for Numeric.array(map(...))"""
-    return array(map(fn,*args))
-
-def amin(m,axis=0):
-    """amin(m,axis=0) returns the minimum of m along dimension axis.
-    """
-    return minimum.reduce(asarray(m),axis)
-
-def amax(m,axis=0):
-    """amax(m,axis=0) returns the maximum of m along dimension axis.
-    """
-    return maximum.reduce(asarray(m),axis)
-
-def zeros_like(a):
-    """Return an array of zeros of the shape and typecode of a.
-
-    If you don't explicitly need the array to be zeroed, you should instead
-    use empty_like(), which is faster as it only allocates memory."""
-
-    return zeros(a.shape,a.typecode())
-
-def empty_like(a):
-    """Return an empty (uninitialized) array of the shape and typecode of a.
-
-    Note that this does NOT initialize the returned array.  If you require
-    your array to be initialized, you should use zeros_like().
-
-    This requires Numeric.empty(), which appeared in Numeric 23.7."""
-
-    return empty(a.shape,a.typecode())
-
-def sum_flat(a):
-    """Return the sum of all the elements of a, flattened out.
-
-    It uses a.flat, and if a is not contiguous, a call to ravel(a) is made."""
-
-    if a.iscontiguous():
-        return Numeric.sum(a.flat)
-    else:
-        return Numeric.sum(ravel(a))
-
-def mean_flat(a):
-    """Return the mean of all the elements of a, flattened out."""
-
-    return sum_flat(a)/float(size(a))
-
-def rms_flat(a):
-    """Return the root mean square of all the elements of a, flattened out."""
-
-    return math.sqrt(sum_flat(absolute(a)**2)/float(size(a)))
-
-def l1norm(a):
-    """Return the l1 norm of a, flattened out.
-
-    Implemented as a separate function (not a call to norm() for speed).
-
-    Ref: http://mathworld.wolfram.com/L1-Norm.html"""
-
-    return sum_flat(absolute(a))
-
-def l2norm(a):
-    """Return the l2 norm of a, flattened out.
-
-    Implemented as a separate function (not a call to norm() for speed).
-
-    Ref: http://mathworld.wolfram.com/L2-Norm.html"""
-
-    return math.sqrt(sum_flat(absolute(a)**2))
-
-def norm(a,p=2):
-    """norm(a,p=2) -> l-p norm of a.flat
-
-    Return the l-p norm of a, considered as a flat array.  This is NOT a true
-    matrix norm, since arrays of arbitrary rank are always flattened.
-
-    p can be a number or one of the strings ('inf','Infinity') to get the
-    L-infinity norm.
-
-    Ref: http://mathworld.wolfram.com/VectorNorm.html
-         http://mathworld.wolfram.com/L-Infinity-Norm.html"""
-
-    if p in ('inf','Infinity'):
-        return max(absolute(a).flat)
-    else:
-        return (sum_flat(absolute(a)**p))**(1.0/p)
-
-def frange(xini,xfin=None,delta=None,**kw):
-    """frange([start,] stop[, step, keywords]) -> array of floats
-
-    Return a Numeric array() containing a progression of floats. Similar to
-    arange(), but defaults to a closed interval.
-
-    frange(x0, x1) returns [x0, x0+1, x0+2, ..., x1]; start defaults to 0, and
-    the endpoint *is included*. This behavior is different from that of
-    range() and arange(). This is deliberate, since frange will probably be
-    more useful for generating lists of points for function evaluation, and
-    endpoints are often desired in this use. The usual behavior of range() can
-    be obtained by setting the keyword 'closed=0', in this case frange()
-    basically becomes arange().
-
-    When step is given, it specifies the increment (or decrement). All
-    arguments can be floating point numbers.
-
-    frange(x0,x1,d) returns [x0,x0+d,x0+2d,...,xfin] where xfin<=x1.
-
-    frange can also be called with the keyword 'npts'. This sets the number of
-    points the list should contain (and overrides the value 'step' might have
-    been given). arange() doesn't offer this option.
-
-    Examples:
-    >>> frange(3)
-    array([ 0.,  1.,  2.,  3.])
-    >>> frange(3,closed=0)
-    array([ 0.,  1.,  2.])
-    >>> frange(1,6,2)
-    array([1, 3, 5])
-    >>> frange(1,6.5,npts=5)
-    array([ 1.   ,  2.375,  3.75 ,  5.125,  6.5  ])
-    """
-
-    #defaults
-    kw.setdefault('closed',1)
-    endpoint = kw['closed'] != 0
-
-    # funny logic to allow the *first* argument to be optional (like range())
-    # This was modified with a simpler version from a similar frange() found
-    # at http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66472
-    if xfin == None:
-        xfin = xini + 0.0
-        xini = 0.0
-
-    if delta == None:
-        delta = 1.0
-
-    # compute # of points, spacing and return final list
-    try:
-        npts=kw['npts']
-        delta=(xfin-xini)/float(npts-endpoint)
-    except KeyError:
-        # round() gets npts right even with the vagaries of floating point.
-        npts=int(round((xfin-xini)/delta+endpoint))
-
-    return arange(npts)*delta+xini
-
-def diagonal_matrix(diag):
-    """Return square diagonal matrix whose non-zero elements are given by the
-    input array."""
-
-    return diag*identity(len(diag))
-
-def identity(n,rank=2,typecode='l'):
-    """identity(n,r) returns the identity matrix of shape (n,n,...,n) (rank r).
-
-    For ranks higher than 2, this object is simply a multi-index Kronecker
-    delta:
-                        /  1  if i0=i1=...=iR,
-    id[i0,i1,...,iR] = -|
-                        \  0  otherwise.
-
-    Optionally a typecode may be given (it defaults to 'l').
-
-    Since rank defaults to 2, this function behaves in the default case (when
-    only n is given) like the Numeric identity function."""
-
-    iden = zeros((n,)*rank,typecode=typecode)
-    for i in range(n):
-        idx = (i,)*rank
-        iden[idx] = 1
-    return iden
-
-def base_repr (number, base = 2, padding = 0):
-    """Return the representation of a number in any given base."""
-    chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-    if number < base: \
-       return (padding - 1) * chars [0] + chars [int (number)]
-    max_exponent = int (math.log (number)/math.log (base))
-    max_power = long (base) ** max_exponent
-    lead_digit = int (number/max_power)
-    return chars [lead_digit] + \
-           base_repr (number - max_power * lead_digit, base, \
-                      max (padding - 1, max_exponent))
-
-def binary_repr(number, max_length = 1025):
-    """Return the binary representation of the input number as a string.
-
-    This is more efficient than using base_repr with base 2.
-
-    Increase the value of max_length for very large numbers. Note that on
-    32-bit machines, 2**1023 is the largest integer power of 2 which can be
-    converted to a Python float."""
-
-    assert number < 2L << max_length
-    shifts = map (operator.rshift, max_length * [number], \
-                  range (max_length - 1, -1, -1))
-    digits = map (operator.mod, shifts, max_length * [2])
-    if not digits.count (1): return 0
-    digits = digits [digits.index (1):]
-    return ''.join (map (repr, digits)).replace('L','')
-
-def log2(x,ln2 = math.log(2.0)):
-    """Return the log(x) in base 2.
-
-    This is a _slow_ function but which is guaranteed to return the correct
-    integer value if the input is an ineger exact power of 2."""
-
-    try:
-        bin_n = binary_repr(x)[1:]
-    except (AssertionError,TypeError):
-        return math.log(x)/ln2
-    else:
-        if '1' in bin_n:
-            return math.log(x)/ln2
-        else:
-            return len(bin_n)
-
-def ispower2(n):
-    """Returns the log base 2 of n if n is a power of 2, zero otherwise.
-
-    Note the potential ambiguity if n==1: 2**0==1, interpret accordingly."""
-
-    bin_n = binary_repr(n)[1:]
-    if '1' in bin_n:
-        return 0
-    else:
-        return len(bin_n)
-
-def fromfunction_kw(function, dimensions, **kwargs):
-    """Drop-in replacement for fromfunction() from Numerical Python.
-
-    Allows passing keyword arguments to the desired function.
-
-    Call it as (keywords are optional):
-    fromfunction_kw(MyFunction, dimensions, keywords)
-
-    The function MyFunction() is responsible for handling the dictionary of
-    keywords it will recieve."""
-
-    return function(tuple(indices(dimensions)),**kwargs)
-
-#**************************** end file <numutils.py> ************************

IPython/deathrow/oldfrontend/asyncfrontendbase.py

@@ -1,82 +0,0 b''
-"""
-Base front end class for all async frontends.
-"""
-__docformat__ = "restructuredtext en"
-
-# Tell nose to skip this module
-__test__ = {}
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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
-#-------------------------------------------------------------------------------
-
-# Third-party
-from twisted.python.failure import Failure
-from zope.interface import implements, classProvides
-
-# From IPython
-from IPython.frontend.frontendbase import (FrontEndBase, IFrontEnd,
-                                           IFrontEndFactory)
-from IPython.kernel.core.history import FrontEndHistory
-from IPython.kernel.engineservice import IEngineCore
-
-import uuid
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-class AsyncFrontEndBase(FrontEndBase):
-    """
-    Overrides FrontEndBase to wrap execute in a deferred result.
-    All callbacks are made as callbacks on the deferred result.
-    """
-
-    implements(IFrontEnd)
-    classProvides(IFrontEndFactory)
-
-    def __init__(self, engine=None, history=None):
-        assert(engine==None or IEngineCore.providedBy(engine))
-        self.engine = IEngineCore(engine)
-        if history is None:
-                self.history = FrontEndHistory(input_cache=[''])
-        else:
-            self.history = history
-
-    def execute(self, block, blockID=None):
-        """Execute the block and return the deferred result.
-
-        Parameters:
-            block : {str, AST}
-            blockID : any
-                Caller may provide an ID to identify this block.
-                result['blockID'] := blockID
-
-        Result:
-            Deferred result of self.interpreter.execute
-        """
-
-        if(not self.is_complete(block)):
-            return Failure(Exception("Block is not compilable"))
-
-        if(blockID == None):
-            blockID = uuid.uuid4()
-
-        d = self.engine.execute(block)
-        d.addCallback(self._add_history, block=block)
-        d.addCallbacks(self._add_block_id_for_result,
-                errback=self._add_block_id_for_failure,
-                callbackArgs=(blockID,),
-                errbackArgs=(blockID,))
-        d.addBoth(self.update_cell_prompt, blockID=blockID)
-        d.addCallbacks(self.render_result,
-            errback=self.render_error)
-
-        return d

IPython/deathrow/oldfrontend/cocoa/cocoa_frontend.py

@@ -1,560 +0,0 b''
-# encoding: utf-8
-# -*- test-case-name: IPython.frontend.cocoa.tests.test_cocoa_frontend -*-
-
-"""PyObjC classes to provide a Cocoa frontend to the
-IPython.kernel.engineservice.IEngineBase.
-
-To add an IPython interpreter to a cocoa app, instantiate an
-IPythonCocoaController in a XIB and connect its textView outlet to an
-NSTextView instance in your UI. That's it.
-
-Author: Barry Wark
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-----------------------------------------------------------------------------
-#       Copyright (C) 2008-2011  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 objc
-import uuid
-
-from Foundation import NSObject, NSMutableArray, NSMutableDictionary,\
-                        NSLog, NSNotificationCenter, NSMakeRange,\
-                        NSLocalizedString, NSIntersectionRange,\
-                        NSString, NSAutoreleasePool
-
-from AppKit import NSApplicationWillTerminateNotification, NSBeep,\
-                    NSTextView, NSRulerView, NSVerticalRuler
-
-from pprint import saferepr
-
-import IPython
-from IPython.kernel.engineservice import ThreadedEngineService
-from IPython.frontend.asyncfrontendbase import AsyncFrontEndBase
-
-from twisted.internet.threads import blockingCallFromThread
-from twisted.python.failure import Failure
-
-#-----------------------------------------------------------------------------
-# Classes to implement the Cocoa frontend
-#-----------------------------------------------------------------------------
-
-# TODO:
-#   1. use MultiEngineClient and out-of-process engine rather than
-#       ThreadedEngineService?
-#   2. integrate Xgrid launching of engines
-
-class AutoreleasePoolWrappedThreadedEngineService(ThreadedEngineService):
-    """Wrap all blocks in an NSAutoreleasePool"""
-
-    def wrapped_execute(self, msg, lines):
-        """wrapped_execute"""
-        try:
-            p = NSAutoreleasePool.alloc().init()
-            result = super(AutoreleasePoolWrappedThreadedEngineService,
-                            self).wrapped_execute(msg, lines)
-        finally:
-            p.drain()
-
-        return result
-
-
-
-class Cell(NSObject):
-    """
-    Representation of the prompts, input and output of a cell in the
-    frontend
-    """
-
-    blockNumber = objc.ivar().unsigned_long()
-    blockID = objc.ivar()
-    inputBlock = objc.ivar()
-    output = objc.ivar()
-
-
-
-class CellBlock(object):
-    """
-    Storage for information about text ranges relating to a single cell
-    """
-
-
-    def __init__(self, inputPromptRange, inputRange=None, outputPromptRange=None,
-                outputRange=None):
-        super(CellBlock, self).__init__()
-        self.inputPromptRange = inputPromptRange
-        self.inputRange = inputRange
-        self.outputPromptRange = outputPromptRange
-        self.outputRange = outputRange
-
-    def update_ranges_for_insertion(self, text, textRange):
-        """Update ranges for text insertion at textRange"""
-
-        for r in [self.inputPromptRange,self.inputRange,
-                    self.outputPromptRange, self.outputRange]:
-            if(r == None):
-                continue
-            intersection = NSIntersectionRange(r,textRange)
-            if(intersection.length == 0): #ranges don't intersect
-                if r.location >= textRange.location:
-                    r.location += len(text)
-            else: #ranges intersect
-                if(r.location > textRange.location):
-                    offset = len(text) - intersection.length
-                    r.length -= offset
-                    r.location += offset
-                elif(r.location == textRange.location):
-                    r.length += len(text) - intersection.length
-                else:
-                    r.length -= intersection.length
-
-
-    def update_ranges_for_deletion(self, textRange):
-        """Update ranges for text deletion at textRange"""
-
-        for r in [self.inputPromptRange,self.inputRange,
-                    self.outputPromptRange, self.outputRange]:
-            if(r==None):
-                continue
-            intersection = NSIntersectionRange(r, textRange)
-            if(intersection.length == 0): #ranges don't intersect
-                if r.location >= textRange.location:
-                    r.location -= textRange.length
-            else: #ranges intersect
-                if(r.location > textRange.location):
-                    offset = intersection.length
-                    r.length -= offset
-                    r.location += offset
-                elif(r.location == textRange.location):
-                    r.length += intersection.length
-                else:
-                    r.length -= intersection.length
-
-    def __repr__(self):
-        return 'CellBlock('+ str((self.inputPromptRange,
-                                self.inputRange,
-                                self.outputPromptRange,
-                                self.outputRange)) + ')'
-
-
-
-
-class IPythonCocoaController(NSObject, AsyncFrontEndBase):
-    userNS = objc.ivar() #mirror of engine.user_ns (key=>str(value))
-    waitingForEngine = objc.ivar().bool()
-    textView = objc.IBOutlet()
-
-    def init(self):
-        self = super(IPythonCocoaController, self).init()
-        AsyncFrontEndBase.__init__(self,
-                    engine=AutoreleasePoolWrappedThreadedEngineService())
-        if(self != None):
-            self._common_init()
-
-        return self
-
-    def _common_init(self):
-        """_common_init"""
-
-        self.userNS = NSMutableDictionary.dictionary()
-        self.waitingForEngine = False
-
-        self.lines = {}
-        self.tabSpaces = 4
-        self.tabUsesSpaces = True
-        self.currentBlockID = self.next_block_ID()
-        self.blockRanges = {} # blockID=>CellBlock
-
-
-    def awakeFromNib(self):
-        """awakeFromNib"""
-
-        self._common_init()
-
-        # Start the IPython engine
-        self.engine.startService()
-        NSLog('IPython engine started')
-
-        # Register for app termination
-        nc = NSNotificationCenter.defaultCenter()
-        nc.addObserver_selector_name_object_(
-                                    self,
-                                    'appWillTerminate:',
-                                    NSApplicationWillTerminateNotification,
-                                    None)
-
-        self.textView.setDelegate_(self)
-        self.textView.enclosingScrollView().setHasVerticalRuler_(True)
-        r = NSRulerView.alloc().initWithScrollView_orientation_(
-                                        self.textView.enclosingScrollView(),
-                                        NSVerticalRuler)
-        self.verticalRulerView = r
-        self.verticalRulerView.setClientView_(self.textView)
-        self._start_cli_banner()
-        self.start_new_block()
-
-
-    def appWillTerminate_(self, notification):
-        """appWillTerminate"""
-
-        self.engine.stopService()
-
-
-    def complete(self, token):
-        """Complete token in engine's user_ns
-
-        Parameters
-        ----------
-        token : string
-
-        Result
-        ------
-        Deferred result of
-        IPython.kernel.engineservice.IEngineBase.complete
-        """
-
-        return self.engine.complete(token)
-
-
-    def execute(self, block, blockID=None):
-        self.waitingForEngine = True
-        self.willChangeValueForKey_('commandHistory')
-        d = super(IPythonCocoaController, self).execute(block,
-                                                        blockID)
-        d.addBoth(self._engine_done)
-        d.addCallback(self._update_user_ns)
-
-        return d
-
-
-    def push_(self, namespace):
-        """Push dictionary of key=>values to python namespace"""
-
-        self.waitingForEngine = True
-        self.willChangeValueForKey_('commandHistory')
-        d = self.engine.push(namespace)
-        d.addBoth(self._engine_done)
-        d.addCallback(self._update_user_ns)
-
-
-    def pull_(self, keys):
-        """Pull keys from python namespace"""
-
-        self.waitingForEngine = True
-        result = blockingCallFromThread(self.engine.pull, keys)
-        self.waitingForEngine = False
-
-    @objc.signature('v@:@I')
-    def executeFileAtPath_encoding_(self, path, encoding):
-        """Execute file at path in an empty namespace. Update the engine
-        user_ns with the resulting locals."""
-
-        lines,err = NSString.stringWithContentsOfFile_encoding_error_(
-            path,
-            encoding,
-            None)
-        self.engine.execute(lines)
-
-
-    def _engine_done(self, x):
-        self.waitingForEngine = False
-        self.didChangeValueForKey_('commandHistory')
-        return x
-
-    def _update_user_ns(self, result):
-        """Update self.userNS from self.engine's namespace"""
-        d = self.engine.keys()
-        d.addCallback(self._get_engine_namespace_values_for_keys)
-
-        return result
-
-
-    def _get_engine_namespace_values_for_keys(self, keys):
-        d = self.engine.pull(keys)
-        d.addCallback(self._store_engine_namespace_values, keys=keys)
-
-
-    def _store_engine_namespace_values(self, values, keys=[]):
-        assert(len(values) == len(keys))
-        self.willChangeValueForKey_('userNS')
-        for (k,v) in zip(keys,values):
-            self.userNS[k] = saferepr(v)
-        self.didChangeValueForKey_('userNS')
-
-
-    def update_cell_prompt(self, result, blockID=None):
-        print self.blockRanges
-        if(isinstance(result, Failure)):
-            prompt = self.input_prompt()
-
-        else:
-            prompt = self.input_prompt(number=result['number'])
-
-        r = self.blockRanges[blockID].inputPromptRange
-        self.insert_text(prompt,
-                textRange=r,
-                scrollToVisible=False
-                )
-
-        return result
-
-
-    def render_result(self, result):
-        blockID = result['blockID']
-        inputRange = self.blockRanges[blockID].inputRange
-        del self.blockRanges[blockID]
-
-        #print inputRange,self.current_block_range()
-        self.insert_text('\n' +
-                self.output_prompt(number=result['number']) +
-                result.get('display',{}).get('pprint','') +
-                '\n\n',
-                textRange=NSMakeRange(inputRange.location+inputRange.length,
-                                    0))
-        return result
-
-
-    def render_error(self, failure):
-        print failure
-        blockID = failure.blockID
-        inputRange = self.blockRanges[blockID].inputRange
-        self.insert_text('\n' +
-                        self.output_prompt() +
-                        '\n' +
-                        failure.getErrorMessage() +
-                        '\n\n',
-                        textRange=NSMakeRange(inputRange.location +
-                                                inputRange.length,
-                                                0))
-        self.start_new_block()
-        return failure
-
-
-    def _start_cli_banner(self):
-        """Print banner"""
-
-        banner = """IPython1 %s -- An enhanced Interactive Python.""" % \
-                    IPython.__version__
-
-        self.insert_text(banner + '\n\n')
-
-
-    def start_new_block(self):
-        """"""
-
-        self.currentBlockID = self.next_block_ID()
-        self.blockRanges[self.currentBlockID] = self.new_cell_block()
-        self.insert_text(self.input_prompt(),
-            textRange=self.current_block_range().inputPromptRange)
-
-
-
-    def next_block_ID(self):
-
-        return uuid.uuid4()
-
-    def new_cell_block(self):
-        """A new CellBlock at the end of self.textView.textStorage()"""
-
-        return CellBlock(NSMakeRange(self.textView.textStorage().length(),
-                                    0), #len(self.input_prompt())),
-                        NSMakeRange(self.textView.textStorage().length(),# + len(self.input_prompt()),
-                                    0))
-
-
-    def current_block_range(self):
-        return self.blockRanges.get(self.currentBlockID,
-                        self.new_cell_block())
-
-    def current_block(self):
-        """The current block's text"""
-
-        return self.text_for_range(self.current_block_range().inputRange)
-
-    def text_for_range(self, textRange):
-        """text_for_range"""
-
-        ts = self.textView.textStorage()
-        return ts.string().substringWithRange_(textRange)
-
-    def current_line(self):
-        block = self.text_for_range(self.current_block_range().inputRange)
-        block = block.split('\n')
-        return block[-1]
-
-
-    def insert_text(self, string=None, textRange=None, scrollToVisible=True):
-        """Insert text into textView at textRange, updating blockRanges
-        as necessary
-        """
-        if(textRange == None):
-            #range for end of text
-            textRange = NSMakeRange(self.textView.textStorage().length(), 0)
-
-
-        self.textView.replaceCharactersInRange_withString_(
-            textRange, string)
-
-        for r in self.blockRanges.itervalues():
-            r.update_ranges_for_insertion(string, textRange)
-
-        self.textView.setSelectedRange_(textRange)
-        if(scrollToVisible):
-            self.textView.scrollRangeToVisible_(textRange)
-
-
-
-    def replace_current_block_with_string(self, textView, string):
-        textView.replaceCharactersInRange_withString_(
-                                    self.current_block_range().inputRange,
-                                    string)
-        self.current_block_range().inputRange.length = len(string)
-        r = NSMakeRange(textView.textStorage().length(), 0)
-        textView.scrollRangeToVisible_(r)
-        textView.setSelectedRange_(r)
-
-
-    def current_indent_string(self):
-        """returns string for indent or None if no indent"""
-
-        return self._indent_for_block(self.current_block())
-
-
-    def _indent_for_block(self, block):
-        lines = block.split('\n')
-        if(len(lines) > 1):
-            currentIndent = len(lines[-1]) - len(lines[-1].lstrip())
-            if(currentIndent == 0):
-                currentIndent = self.tabSpaces
-
-            if(self.tabUsesSpaces):
-                result = ' ' * currentIndent
-            else:
-                result = '\t' * (currentIndent/self.tabSpaces)
-        else:
-            result = None
-
-        return result
-
-
-    # NSTextView delegate methods...
-    def textView_doCommandBySelector_(self, textView, selector):
-        assert(textView == self.textView)
-        NSLog("textView_doCommandBySelector_: "+selector)
-
-
-        if(selector == 'insertNewline:'):
-            indent = self.current_indent_string()
-            if(indent):
-                line = indent + self.current_line()
-            else:
-                line = self.current_line()
-
-            if(self.is_complete(self.current_block())):
-                self.execute(self.current_block(),
-                                blockID=self.currentBlockID)
-                self.start_new_block()
-
-                return True
-
-            return False
-
-        elif(selector == 'moveUp:'):
-            prevBlock = self.get_history_previous(self.current_block())
-            if(prevBlock != None):
-                self.replace_current_block_with_string(textView, prevBlock)
-            else:
-                NSBeep()
-            return True
-
-        elif(selector == 'moveDown:'):
-            nextBlock = self.get_history_next()
-            if(nextBlock != None):
-                self.replace_current_block_with_string(textView, nextBlock)
-            else:
-                NSBeep()
-            return True
-
-        elif(selector == 'moveToBeginningOfParagraph:'):
-            textView.setSelectedRange_(NSMakeRange(
-                            self.current_block_range().inputRange.location,
-                            0))
-            return True
-        elif(selector == 'moveToEndOfParagraph:'):
-            textView.setSelectedRange_(NSMakeRange(
-                            self.current_block_range().inputRange.location + \
-                            self.current_block_range().inputRange.length, 0))
-            return True
-        elif(selector == 'deleteToEndOfParagraph:'):
-            if(textView.selectedRange().location <= \
-                self.current_block_range().location):
-                raise NotImplemented()
-
-            return False # don't actually handle the delete
-
-        elif(selector == 'insertTab:'):
-            if(len(self.current_line().strip()) == 0): #only white space
-                return False
-            else:
-                self.textView.complete_(self)
-                return True
-
-        elif(selector == 'deleteBackward:'):
-            #if we're at the beginning of the current block, ignore
-            if(textView.selectedRange().location == \
-                self.current_block_range().inputRange.location):
-                return True
-            else:
-                for r in self.blockRanges.itervalues():
-                    deleteRange = textView.selectedRange
-                    if(deleteRange.length == 0):
-                        deleteRange.location -= 1
-                        deleteRange.length = 1
-                    r.update_ranges_for_deletion(deleteRange)
-                return False
-        return False
-
-
-    def textView_shouldChangeTextInRanges_replacementStrings_(self,
-        textView, ranges, replacementStrings):
-        """
-        Delegate method for NSTextView.
-
-        Refuse change text in ranges not at end, but make those changes at
-        end.
-        """
-
-        assert(len(ranges) == len(replacementStrings))
-        allow = True
-        for r,s in zip(ranges, replacementStrings):
-            r = r.rangeValue()
-            if(textView.textStorage().length() > 0 and
-                r.location < self.current_block_range().inputRange.location):
-                self.insert_text(s)
-                allow = False
-
-        return allow
-
-    def textView_completions_forPartialWordRange_indexOfSelectedItem_(self,
-        textView, words, charRange, index):
-        try:
-            ts = textView.textStorage()
-            token = ts.string().substringWithRange_(charRange)
-            completions = blockingCallFromThread(self.complete, token)
-        except:
-            completions = objc.nil
-            NSBeep()
-
-        return (completions,0)
-
-

IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/English.lproj/MainMenu.xib

@@ -1,3424 +0,0 b''
-<?xml version="1.0" encoding="UTF-8"?>
-<archive type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="7.01">
-	<data>
-		<int key="IBDocument.SystemTarget">1050</int>
-		<string key="IBDocument.SystemVersion">9D34</string>
-		<string key="IBDocument.InterfaceBuilderVersion">629</string>
-		<string key="IBDocument.AppKitVersion">949.33</string>
-		<string key="IBDocument.HIToolboxVersion">352.00</string>
-		<object class="NSMutableArray" key="IBDocument.EditedObjectIDs">
-			<bool key="EncodedWithXMLCoder">YES</bool>
-			<integer value="416"/>
-			<integer value="29"/>
-		</object>
-		<object class="NSArray" key="IBDocument.PluginDependencies">
-			<bool key="EncodedWithXMLCoder">YES</bool>
-			<string id="885801228">com.apple.InterfaceBuilderKit</string>
-			<string id="113577022">com.apple.InterfaceBuilder.CocoaPlugin</string>
-		</object>
-		<object class="NSMutableArray" key="IBDocument.RootObjects" id="1048">
-			<bool key="EncodedWithXMLCoder">YES</bool>
-			<object class="NSCustomObject" id="1021">
-				<string key="NSClassName" id="190635311">NSApplication</string>
-			</object>
-			<object class="NSCustomObject" id="1014">
-				<string key="NSClassName">FirstResponder</string>
-			</object>
-			<object class="NSCustomObject" id="1050">
-				<reference key="NSClassName" ref="190635311"/>
-			</object>
-			<object class="NSMenu" id="649796088">
-				<string key="NSTitle">AMainMenu</string>
-				<object class="NSMutableArray" key="NSMenuItems">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-					<object class="NSMenuItem" id="694149608">
-						<reference key="NSMenu" ref="649796088"/>
-						<string key="NSTitle" id="837240250">IPython1Sandbox</string>
-						<string key="NSKeyEquiv" id="255189770"/>
-						<int key="NSKeyEquivModMask">1048576</int>
-						<int key="NSMnemonicLoc">2147483647</int>
-						<object class="NSCustomResource" key="NSOnImage" id="271266416">
-							<string key="NSClassName" id="375865337">NSImage</string>
-							<string key="NSResourceName">NSMenuCheckmark</string>
-						</object>
-						<object class="NSCustomResource" key="NSMixedImage" id="508123839">
-							<reference key="NSClassName" ref="375865337"/>
-							<string key="NSResourceName">NSMenuMixedState</string>
-						</object>
-						<string key="NSAction">submenuAction:</string>
-						<object class="NSMenu" key="NSSubmenu" id="110575045">
-							<reference key="NSTitle" ref="837240250"/>
-							<object class="NSMutableArray" key="NSMenuItems">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSMenuItem" id="238522557">
-									<reference key="NSMenu" ref="110575045"/>
-									<string key="NSTitle">About IPython1Sandbox</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="304266470">
-									<reference key="NSMenu" ref="110575045"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="609285721">
-									<reference key="NSMenu" ref="110575045"/>
-									<string type="base64-UTF8" key="NSTitle">UHJlZmVyZW5jZXPigKY</string>
-									<string key="NSKeyEquiv">,</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="481834944">
-									<reference key="NSMenu" ref="110575045"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="1046388886">
-									<reference key="NSMenu" ref="110575045"/>
-									<string key="NSTitle" id="642338826">Services</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-									<string key="NSAction">submenuAction:</string>
-									<object class="NSMenu" key="NSSubmenu" id="752062318">
-										<reference key="NSTitle" ref="642338826"/>
-										<object class="NSMutableArray" key="NSMenuItems">
-											<bool key="EncodedWithXMLCoder">YES</bool>
-										</object>
-										<string key="NSName">_NSServicesMenu</string>
-									</object>
-								</object>
-								<object class="NSMenuItem" id="646227648">
-									<reference key="NSMenu" ref="110575045"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="755159360">
-									<reference key="NSMenu" ref="110575045"/>
-									<string key="NSTitle">Hide IPython1Sandbox</string>
-									<string key="NSKeyEquiv" id="940330891">h</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="342932134">
-									<reference key="NSMenu" ref="110575045"/>
-									<string key="NSTitle">Hide Others</string>
-									<reference key="NSKeyEquiv" ref="940330891"/>
-									<int key="NSKeyEquivModMask">1572864</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="908899353">
-									<reference key="NSMenu" ref="110575045"/>
-									<string key="NSTitle">Show All</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="1056857174">
-									<reference key="NSMenu" ref="110575045"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="632727374">
-									<reference key="NSMenu" ref="110575045"/>
-									<string key="NSTitle">Quit IPython1Sandbox</string>
-									<string key="NSKeyEquiv">q</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-							</object>
-							<string key="NSName">_NSAppleMenu</string>
-						</object>
-					</object>
-					<object class="NSMenuItem" id="379814623">
-						<reference key="NSMenu" ref="649796088"/>
-						<string key="NSTitle" id="881404960">File</string>
-						<reference key="NSKeyEquiv" ref="255189770"/>
-						<int key="NSKeyEquivModMask">1048576</int>
-						<int key="NSMnemonicLoc">2147483647</int>
-						<reference key="NSOnImage" ref="271266416"/>
-						<reference key="NSMixedImage" ref="508123839"/>
-						<string key="NSAction">submenuAction:</string>
-						<object class="NSMenu" key="NSSubmenu" id="720053764">
-							<reference key="NSTitle" ref="881404960"/>
-							<object class="NSMutableArray" key="NSMenuItems">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSMenuItem" id="705341025">
-									<reference key="NSMenu" ref="720053764"/>
-									<string key="NSTitle">New</string>
-									<string key="NSKeyEquiv">n</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="722745758">
-									<reference key="NSMenu" ref="720053764"/>
-									<string type="base64-UTF8" key="NSTitle">T3BlbuKApg</string>
-									<string key="NSKeyEquiv">o</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="1025936716">
-									<reference key="NSMenu" ref="720053764"/>
-									<string key="NSTitle" id="975517829">Open Recent</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-									<string key="NSAction">submenuAction:</string>
-									<object class="NSMenu" key="NSSubmenu" id="1065607017">
-										<reference key="NSTitle" ref="975517829"/>
-										<object class="NSMutableArray" key="NSMenuItems">
-											<bool key="EncodedWithXMLCoder">YES</bool>
-											<object class="NSMenuItem" id="759406840">
-												<reference key="NSMenu" ref="1065607017"/>
-												<string key="NSTitle">Clear Menu</string>
-												<reference key="NSKeyEquiv" ref="255189770"/>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-										</object>
-										<string key="NSName">_NSRecentDocumentsMenu</string>
-									</object>
-								</object>
-								<object class="NSMenuItem" id="425164168">
-									<reference key="NSMenu" ref="720053764"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="776162233">
-									<reference key="NSMenu" ref="720053764"/>
-									<string key="NSTitle">Close</string>
-									<string key="NSKeyEquiv">w</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="1023925487">
-									<reference key="NSMenu" ref="720053764"/>
-									<string key="NSTitle">Save</string>
-									<string key="NSKeyEquiv">s</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="117038363">
-									<reference key="NSMenu" ref="720053764"/>
-									<string type="base64-UTF8" key="NSTitle">U2F2ZSBBc+KApg</string>
-									<string key="NSKeyEquiv">S</string>
-									<int key="NSKeyEquivModMask">1179648</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="579971712">
-									<reference key="NSMenu" ref="720053764"/>
-									<string key="NSTitle">Revert to Saved</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="1010469920">
-									<reference key="NSMenu" ref="720053764"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="294629803">
-									<reference key="NSMenu" ref="720053764"/>
-									<string key="NSTitle">Page Setup...</string>
-									<string key="NSKeyEquiv">P</string>
-									<int key="NSKeyEquivModMask">1179648</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-									<reference key="NSToolTip" ref="255189770"/>
-								</object>
-								<object class="NSMenuItem" id="49223823">
-									<reference key="NSMenu" ref="720053764"/>
-									<string type="base64-UTF8" key="NSTitle">UHJpbnTigKY</string>
-									<string key="NSKeyEquiv">p</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-							</object>
-						</object>
-					</object>
-					<object class="NSMenuItem" id="952259628">
-						<reference key="NSMenu" ref="649796088"/>
-						<string key="NSTitle" id="1037326483">Edit</string>
-						<reference key="NSKeyEquiv" ref="255189770"/>
-						<int key="NSKeyEquivModMask">1048576</int>
-						<int key="NSMnemonicLoc">2147483647</int>
-						<reference key="NSOnImage" ref="271266416"/>
-						<reference key="NSMixedImage" ref="508123839"/>
-						<string key="NSAction">submenuAction:</string>
-						<object class="NSMenu" key="NSSubmenu" id="789758025">
-							<reference key="NSTitle" ref="1037326483"/>
-							<object class="NSMutableArray" key="NSMenuItems">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSMenuItem" id="1058277027">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle">Undo</string>
-									<string key="NSKeyEquiv">z</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="790794224">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle">Redo</string>
-									<string key="NSKeyEquiv">Z</string>
-									<int key="NSKeyEquivModMask">1179648</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="1040322652">
-									<reference key="NSMenu" ref="789758025"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="296257095">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle">Cut</string>
-									<string key="NSKeyEquiv">x</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="860595796">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle">Copy</string>
-									<string key="NSKeyEquiv">c</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="29853731">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle">Paste</string>
-									<string key="NSKeyEquiv">v</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="437104165">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle">Delete</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="583158037">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle">Select All</string>
-									<string key="NSKeyEquiv">a</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="212016141">
-									<reference key="NSMenu" ref="789758025"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="892235320">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle" id="688083180">Find</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-									<string key="NSAction">submenuAction:</string>
-									<object class="NSMenu" key="NSSubmenu" id="963351320">
-										<reference key="NSTitle" ref="688083180"/>
-										<object class="NSMutableArray" key="NSMenuItems">
-											<bool key="EncodedWithXMLCoder">YES</bool>
-											<object class="NSMenuItem" id="447796847">
-												<reference key="NSMenu" ref="963351320"/>
-												<string type="base64-UTF8" key="NSTitle">RmluZOKApg</string>
-												<string key="NSKeyEquiv" id="469505129">f</string>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-												<int key="NSTag">1</int>
-											</object>
-											<object class="NSMenuItem" id="326711663">
-												<reference key="NSMenu" ref="963351320"/>
-												<string key="NSTitle">Find Next</string>
-												<string key="NSKeyEquiv" id="762398675">g</string>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-												<int key="NSTag">2</int>
-											</object>
-											<object class="NSMenuItem" id="270902937">
-												<reference key="NSMenu" ref="963351320"/>
-												<string key="NSTitle">Find Previous</string>
-												<string key="NSKeyEquiv" id="819654342">G</string>
-												<int key="NSKeyEquivModMask">1179648</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-												<int key="NSTag">3</int>
-											</object>
-											<object class="NSMenuItem" id="159080638">
-												<reference key="NSMenu" ref="963351320"/>
-												<string key="NSTitle">Use Selection for Find</string>
-												<string key="NSKeyEquiv">e</string>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-												<int key="NSTag">7</int>
-											</object>
-											<object class="NSMenuItem" id="88285865">
-												<reference key="NSMenu" ref="963351320"/>
-												<string key="NSTitle">Jump to Selection</string>
-												<string key="NSKeyEquiv">j</string>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-										</object>
-									</object>
-								</object>
-								<object class="NSMenuItem" id="972420730">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle" id="739167250">Spelling and Grammar</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-									<string key="NSAction">submenuAction:</string>
-									<object class="NSMenu" key="NSSubmenu" id="769623530">
-										<reference key="NSTitle" ref="739167250"/>
-										<object class="NSMutableArray" key="NSMenuItems">
-											<bool key="EncodedWithXMLCoder">YES</bool>
-											<object class="NSMenuItem" id="679648819">
-												<reference key="NSMenu" ref="769623530"/>
-												<string type="base64-UTF8" key="NSTitle">U2hvdyBTcGVsbGluZ+KApg</string>
-												<string key="NSKeyEquiv">:</string>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-											<object class="NSMenuItem" id="96193923">
-												<reference key="NSMenu" ref="769623530"/>
-												<string key="NSTitle">Check Spelling</string>
-												<string key="NSKeyEquiv">;</string>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-											<object class="NSMenuItem" id="948374510">
-												<reference key="NSMenu" ref="769623530"/>
-												<string key="NSTitle">Check Spelling While Typing</string>
-												<reference key="NSKeyEquiv" ref="255189770"/>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-											<object class="NSMenuItem" id="967646866">
-												<reference key="NSMenu" ref="769623530"/>
-												<string key="NSTitle">Check Grammar With Spelling</string>
-												<reference key="NSKeyEquiv" ref="255189770"/>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-										</object>
-									</object>
-								</object>
-								<object class="NSMenuItem" id="507821607">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle" id="904739598">Substitutions</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-									<string key="NSAction">submenuAction:</string>
-									<object class="NSMenu" key="NSSubmenu" id="698887838">
-										<reference key="NSTitle" ref="904739598"/>
-										<object class="NSMutableArray" key="NSMenuItems">
-											<bool key="EncodedWithXMLCoder">YES</bool>
-											<object class="NSMenuItem" id="605118523">
-												<reference key="NSMenu" ref="698887838"/>
-												<string key="NSTitle">Smart Copy/Paste</string>
-												<reference key="NSKeyEquiv" ref="469505129"/>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-												<int key="NSTag">1</int>
-											</object>
-											<object class="NSMenuItem" id="197661976">
-												<reference key="NSMenu" ref="698887838"/>
-												<string key="NSTitle">Smart Quotes</string>
-												<reference key="NSKeyEquiv" ref="762398675"/>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-												<int key="NSTag">2</int>
-											</object>
-											<object class="NSMenuItem" id="708854459">
-												<reference key="NSMenu" ref="698887838"/>
-												<string key="NSTitle">Smart Links</string>
-												<reference key="NSKeyEquiv" ref="819654342"/>
-												<int key="NSKeyEquivModMask">1179648</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-												<int key="NSTag">3</int>
-											</object>
-										</object>
-									</object>
-								</object>
-								<object class="NSMenuItem" id="676164635">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle" id="812002426">Speech</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-									<string key="NSAction">submenuAction:</string>
-									<object class="NSMenu" key="NSSubmenu" id="785027613">
-										<reference key="NSTitle" ref="812002426"/>
-										<object class="NSMutableArray" key="NSMenuItems">
-											<bool key="EncodedWithXMLCoder">YES</bool>
-											<object class="NSMenuItem" id="731782645">
-												<reference key="NSMenu" ref="785027613"/>
-												<string key="NSTitle">Start Speaking</string>
-												<reference key="NSKeyEquiv" ref="255189770"/>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-											<object class="NSMenuItem" id="680220178">
-												<reference key="NSMenu" ref="785027613"/>
-												<string key="NSTitle">Stop Speaking</string>
-												<reference key="NSKeyEquiv" ref="255189770"/>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-										</object>
-									</object>
-								</object>
-							</object>
-						</object>
-					</object>
-					<object class="NSMenuItem" id="626404410">
-						<reference key="NSMenu" ref="649796088"/>
-						<string key="NSTitle" id="241242548">Format</string>
-						<reference key="NSKeyEquiv" ref="255189770"/>
-						<int key="NSKeyEquivModMask">1048576</int>
-						<int key="NSMnemonicLoc">2147483647</int>
-						<reference key="NSOnImage" ref="271266416"/>
-						<reference key="NSMixedImage" ref="508123839"/>
-						<string key="NSAction">submenuAction:</string>
-						<object class="NSMenu" key="NSSubmenu" id="502084290">
-							<reference key="NSTitle" ref="241242548"/>
-							<object class="NSMutableArray" key="NSMenuItems">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSMenuItem" id="519768076">
-									<reference key="NSMenu" ref="502084290"/>
-									<string key="NSTitle">Show Fonts</string>
-									<string key="NSKeyEquiv" id="806579634">t</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="1028416764">
-									<reference key="NSMenu" ref="502084290"/>
-									<string key="NSTitle">Show Colors</string>
-									<string key="NSKeyEquiv">C</string>
-									<int key="NSKeyEquivModMask">1179648</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-							</object>
-						</object>
-					</object>
-					<object class="NSMenuItem" id="586577488">
-						<reference key="NSMenu" ref="649796088"/>
-						<string key="NSTitle" id="809723865">View</string>
-						<reference key="NSKeyEquiv" ref="255189770"/>
-						<int key="NSKeyEquivModMask">1048576</int>
-						<int key="NSMnemonicLoc">2147483647</int>
-						<reference key="NSOnImage" ref="271266416"/>
-						<reference key="NSMixedImage" ref="508123839"/>
-						<string key="NSAction">submenuAction:</string>
-						<object class="NSMenu" key="NSSubmenu" id="466310130">
-							<reference key="NSTitle" ref="809723865"/>
-							<object class="NSMutableArray" key="NSMenuItems">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSMenuItem" id="102151532">
-									<reference key="NSMenu" ref="466310130"/>
-									<string key="NSTitle">Show Toolbar</string>
-									<reference key="NSKeyEquiv" ref="806579634"/>
-									<int key="NSKeyEquivModMask">1572864</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="237841660">
-									<reference key="NSMenu" ref="466310130"/>
-									<string type="base64-UTF8" key="NSTitle">Q3VzdG9taXplIFRvb2xiYXLigKY</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-							</object>
-						</object>
-					</object>
-					<object class="NSMenuItem" id="713487014">
-						<reference key="NSMenu" ref="649796088"/>
-						<string key="NSTitle" id="64165424">Window</string>
-						<reference key="NSKeyEquiv" ref="255189770"/>
-						<int key="NSKeyEquivModMask">1048576</int>
-						<int key="NSMnemonicLoc">2147483647</int>
-						<reference key="NSOnImage" ref="271266416"/>
-						<reference key="NSMixedImage" ref="508123839"/>
-						<string key="NSAction">submenuAction:</string>
-						<object class="NSMenu" key="NSSubmenu" id="835318025">
-							<reference key="NSTitle" ref="64165424"/>
-							<object class="NSMutableArray" key="NSMenuItems">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSMenuItem" id="1011231497">
-									<reference key="NSMenu" ref="835318025"/>
-									<string key="NSTitle">Minimize</string>
-									<string key="NSKeyEquiv">m</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="575023229">
-									<reference key="NSMenu" ref="835318025"/>
-									<string key="NSTitle">Zoom</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="299356726">
-									<reference key="NSMenu" ref="835318025"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="625202149">
-									<reference key="NSMenu" ref="835318025"/>
-									<string key="NSTitle">Bring All to Front</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-							</object>
-							<string key="NSName">_NSWindowsMenu</string>
-						</object>
-					</object>
-					<object class="NSMenuItem" id="391199113">
-						<reference key="NSMenu" ref="649796088"/>
-						<string key="NSTitle" id="461919786">Help</string>
-						<reference key="NSKeyEquiv" ref="255189770"/>
-						<int key="NSKeyEquivModMask">1048576</int>
-						<int key="NSMnemonicLoc">2147483647</int>
-						<reference key="NSOnImage" ref="271266416"/>
-						<reference key="NSMixedImage" ref="508123839"/>
-						<string key="NSAction">submenuAction:</string>
-						<object class="NSMenu" key="NSSubmenu" id="374024848">
-							<reference key="NSTitle" ref="461919786"/>
-							<object class="NSMutableArray" key="NSMenuItems">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSMenuItem" id="238773614">
-									<reference key="NSMenu" ref="374024848"/>
-									<string key="NSTitle">IPython1Sandbox Help</string>
-									<string key="NSKeyEquiv">?</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-							</object>
-						</object>
-					</object>
-				</object>
-				<string key="NSName">_NSMainMenu</string>
-			</object>
-			<object class="NSWindowTemplate" id="972006081">
-				<int key="NSWindowStyleMask">15</int>
-				<int key="NSWindowBacking">2</int>
-				<string key="NSWindowRect">{{335, 413}, {725, 337}}</string>
-				<int key="NSWTFlags">1946157056</int>
-				<string key="NSWindowTitle">IPython1 (Cocoa)</string>
-				<string key="NSWindowClass">NSWindow</string>
-				<nil key="NSViewClass"/>
-				<object class="NSView" key="NSWindowView" id="439893737">
-					<reference key="NSNextResponder"/>
-					<int key="NSvFlags">256</int>
-					<object class="NSMutableArray" key="NSSubviews">
-						<bool key="EncodedWithXMLCoder">YES</bool>
-						<object class="NSSplitView" id="741760375">
-							<reference key="NSNextResponder" ref="439893737"/>
-							<int key="NSvFlags">274</int>
-							<object class="NSMutableArray" key="NSSubviews">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSBox" id="554641139">
-									<reference key="NSNextResponder" ref="741760375"/>
-									<int key="NSvFlags">22</int>
-									<object class="NSMutableArray" key="NSSubviews">
-										<bool key="EncodedWithXMLCoder">YES</bool>
-										<object class="NSView" id="597872307">
-											<reference key="NSNextResponder" ref="554641139"/>
-											<int key="NSvFlags">256</int>
-											<object class="NSMutableArray" key="NSSubviews">
-												<bool key="EncodedWithXMLCoder">YES</bool>
-												<object class="NSScrollView" id="188193463">
-													<reference key="NSNextResponder" ref="597872307"/>
-													<int key="NSvFlags">274</int>
-													<object class="NSMutableArray" key="NSSubviews">
-														<bool key="EncodedWithXMLCoder">YES</bool>
-														<object class="NSClipView" id="638544389">
-															<reference key="NSNextResponder" ref="188193463"/>
-															<int key="NSvFlags">2304</int>
-															<object class="NSMutableArray" key="NSSubviews">
-																<bool key="EncodedWithXMLCoder">YES</bool>
-																<object class="NSTextView" id="163417131">
-																	<reference key="NSNextResponder" ref="638544389"/>
-																	<int key="NSvFlags">2322</int>
-																	<object class="NSMutableSet" key="NSDragTypes">
-																		<bool key="EncodedWithXMLCoder">YES</bool>
-																		<object class="NSMutableArray" key="set.sortedObjects">
-																			<bool key="EncodedWithXMLCoder">YES</bool>
-																			<string>Apple HTML pasteboard type</string>
-																			<string>Apple PDF pasteboard type</string>
-																			<string>Apple PICT pasteboard type</string>
-																			<string>Apple PNG pasteboard type</string>
-																			<string>Apple URL pasteboard type</string>
-																			<string>CorePasteboardFlavorType 0x6D6F6F76</string>
-																			<string>CorePasteboardFlavorType 0x75726C20</string>
-																			<string>NSColor pasteboard type</string>
-																			<string>NSFilenamesPboardType</string>
-																			<string>NSStringPboardType</string>
-																			<string>NeXT Encapsulated PostScript v1.2 pasteboard type</string>
-																			<string>NeXT RTFD pasteboard type</string>
-																			<string>NeXT Rich Text Format v1.0 pasteboard type</string>
-																			<string>NeXT TIFF v4.0 pasteboard type</string>
-																			<string>NeXT font pasteboard type</string>
-																			<string>NeXT ruler pasteboard type</string>
-																			<string>WebURLsWithTitlesPboardType</string>
-																		</object>
-																	</object>
-																	<string key="NSFrame">{{0, 38}, {433, 14}}</string>
-																	<reference key="NSSuperview" ref="638544389"/>
-																	<reference key="NSWindow"/>
-																	<object class="NSTextContainer" key="NSTextContainer" id="662117317">
-																		<object class="NSLayoutManager" key="NSLayoutManager">
-																			<object class="NSTextStorage" key="NSTextStorage">
-																				<object class="NSMutableString" key="NSString">
-																					<characters key="NS.bytes"/>
-																				</object>
-																				<nil key="NSDelegate"/>
-																			</object>
-																			<object class="NSMutableArray" key="NSTextContainers">
-																				<bool key="EncodedWithXMLCoder">YES</bool>
-																				<reference ref="662117317"/>
-																			</object>
-																			<int key="NSLMFlags">6</int>
-																			<nil key="NSDelegate"/>
-																		</object>
-																		<reference key="NSTextView" ref="163417131"/>
-																		<double key="NSWidth">4.330000e+02</double>
-																		<int key="NSTCFlags">1</int>
-																	</object>
-																	<object class="NSTextViewSharedData" key="NSSharedData">
-																		<int key="NSFlags">346991</int>
-																		<object class="NSColor" key="NSBackgroundColor">
-																			<int key="NSColorSpace">2</int>
-																			<bytes key="NSRGB">MSAwLjk1Mjk0MTI0IDAuODUwOTgwNDYAA</bytes>
-																		</object>
-																		<object class="NSColor" key="NSInsertionColor" id="555789289">
-																			<int key="NSColorSpace">3</int>
-																			<bytes key="NSWhite">MAA</bytes>
-																		</object>
-																		<object class="NSDictionary" key="NSSelectedAttributes">
-																			<bool key="EncodedWithXMLCoder">YES</bool>
-																			<object class="NSMutableArray" key="dict.sortedKeys">
-																				<bool key="EncodedWithXMLCoder">YES</bool>
-																				<string>NSBackgroundColor</string>
-																				<string id="19777717">NSColor</string>
-																			</object>
-																			<object class="NSMutableArray" key="dict.values">
-																				<bool key="EncodedWithXMLCoder">YES</bool>
-																				<object class="NSColor">
-																					<int key="NSColorSpace">6</int>
-																					<string key="NSCatalogName" id="484387293">System</string>
-																					<string key="NSColorName">selectedTextBackgroundColor</string>
-																					<object class="NSColor" key="NSColor" id="377165725">
-																						<int key="NSColorSpace">3</int>
-																						<bytes key="NSWhite">MC42NjY2NjY2OQA</bytes>
-																					</object>
-																				</object>
-																				<object class="NSColor">
-																					<int key="NSColorSpace">6</int>
-																					<reference key="NSCatalogName" ref="484387293"/>
-																					<string key="NSColorName">selectedTextColor</string>
-																					<reference key="NSColor" ref="555789289"/>
-																				</object>
-																			</object>
-																		</object>
-																		<nil key="NSMarkedAttributes"/>
-																		<object class="NSDictionary" key="NSLinkAttributes">
-																			<bool key="EncodedWithXMLCoder">YES</bool>
-																			<object class="NSMutableArray" key="dict.sortedKeys">
-																				<bool key="EncodedWithXMLCoder">YES</bool>
-																				<reference ref="19777717"/>
-																				<string>NSUnderline</string>
-																			</object>
-																			<object class="NSMutableArray" key="dict.values">
-																				<bool key="EncodedWithXMLCoder">YES</bool>
-																				<object class="NSColor">
-																					<int key="NSColorSpace">1</int>
-																					<bytes key="NSRGB">MCAwIDEAA</bytes>
-																				</object>
-																				<integer value="1" id="9"/>
-																			</object>
-																		</object>
-																		<nil key="NSDefaultParagraphStyle"/>
-																	</object>
-																	<int key="NSTVFlags">6</int>
-																	<string key="NSMaxSize">{480, 1e+07}</string>
-																	<string key="NSMinize">{84, 0}</string>
-																	<nil key="NSDelegate"/>
-																</object>
-															</object>
-															<string key="NSFrame">{{1, 1}, {433, 231}}</string>
-															<string key="NSBounds">{{0, 38}, {433, 231}}</string>
-															<reference key="NSSuperview" ref="188193463"/>
-															<reference key="NSWindow"/>
-															<reference key="NSNextKeyView" ref="163417131"/>
-															<reference key="NSDocView" ref="163417131"/>
-															<object class="NSColor" key="NSBGColor" id="521347521">
-																<int key="NSColorSpace">3</int>
-																<bytes key="NSWhite">MQA</bytes>
-															</object>
-															<object class="NSCursor" key="NSCursor">
-																<string key="NSHotSpot">{4, -5}</string>
-																<int key="NSCursorType">1</int>
-															</object>
-															<int key="NScvFlags">4</int>
-														</object>
-														<object class="NSScroller" id="418410897">
-															<reference key="NSNextResponder" ref="188193463"/>
-															<int key="NSvFlags">-2147483392</int>
-															<string key="NSFrame">{{427, 1}, {15, 263}}</string>
-															<reference key="NSSuperview" ref="188193463"/>
-															<reference key="NSWindow"/>
-															<reference key="NSTarget" ref="188193463"/>
-															<string key="NSAction" id="688920982">_doScroller:</string>
-															<double key="NSPercent">3.389175e-01</double>
-														</object>
-														<object class="NSScroller" id="936733673">
-															<reference key="NSNextResponder" ref="188193463"/>
-															<int key="NSvFlags">256</int>
-															<string key="NSFrame">{{-100, -100}, {87, 18}}</string>
-															<reference key="NSSuperview" ref="188193463"/>
-															<reference key="NSWindow"/>
-															<int key="NSsFlags">1</int>
-															<reference key="NSTarget" ref="188193463"/>
-															<reference key="NSAction" ref="688920982"/>
-															<double key="NSCurValue">1.000000e+00</double>
-															<double key="NSPercent">9.456522e-01</double>
-														</object>
-													</object>
-													<string key="NSFrame">{{18, 14}, {435, 233}}</string>
-													<reference key="NSSuperview" ref="597872307"/>
-													<reference key="NSWindow"/>
-													<reference key="NSNextKeyView" ref="638544389"/>
-													<int key="NSsFlags">530</int>
-													<reference key="NSVScroller" ref="418410897"/>
-													<reference key="NSHScroller" ref="936733673"/>
-													<reference key="NSContentView" ref="638544389"/>
-												</object>
-											</object>
-											<string key="NSFrame">{{1, 1}, {471, 257}}</string>
-											<reference key="NSSuperview" ref="554641139"/>
-											<reference key="NSWindow"/>
-										</object>
-									</object>
-									<string key="NSFrameSize">{473, 273}</string>
-									<reference key="NSSuperview" ref="741760375"/>
-									<reference key="NSWindow"/>
-									<string key="NSOffsets" id="1055927954">{0, 0}</string>
-									<object class="NSTextFieldCell" key="NSTitleCell">
-										<int key="NSCellFlags">67239424</int>
-										<int key="NSCellFlags2">0</int>
-										<string key="NSContents">Console</string>
-										<object class="NSFont" key="NSSupport" id="26">
-											<string key="NSName" id="378950370">LucidaGrande</string>
-											<double key="NSSize">1.100000e+01</double>
-											<int key="NSfFlags">3100</int>
-										</object>
-										<object class="NSColor" key="NSBackgroundColor" id="131515055">
-											<int key="NSColorSpace">6</int>
-											<reference key="NSCatalogName" ref="484387293"/>
-											<string key="NSColorName">textBackgroundColor</string>
-											<reference key="NSColor" ref="521347521"/>
-										</object>
-										<object class="NSColor" key="NSTextColor">
-											<int key="NSColorSpace">3</int>
-											<bytes key="NSWhite">MCAwLjgwMDAwMDAxAA</bytes>
-										</object>
-									</object>
-									<reference key="NSContentView" ref="597872307"/>
-									<int key="NSBorderType">1</int>
-									<int key="NSBoxType">0</int>
-									<int key="NSTitlePosition">2</int>
-									<bool key="NSTransparent">NO</bool>
-								</object>
-								<object class="NSBox" id="764100755">
-									<reference key="NSNextResponder" ref="741760375"/>
-									<int key="NSvFlags">51</int>
-									<object class="NSMutableArray" key="NSSubviews">
-										<bool key="EncodedWithXMLCoder">YES</bool>
-										<object class="NSView" id="581281551">
-											<reference key="NSNextResponder" ref="764100755"/>
-											<int key="NSvFlags">256</int>
-											<object class="NSMutableArray" key="NSSubviews">
-												<bool key="EncodedWithXMLCoder">YES</bool>
-												<object class="NSScrollView" id="516244966">
-													<reference key="NSNextResponder" ref="581281551"/>
-													<int key="NSvFlags">274</int>
-													<object class="NSMutableArray" key="NSSubviews">
-														<bool key="EncodedWithXMLCoder">YES</bool>
-														<object class="NSClipView" id="119083427">
-															<reference key="NSNextResponder" ref="516244966"/>
-															<int key="NSvFlags">2304</int>
-															<object class="NSMutableArray" key="NSSubviews">
-																<bool key="EncodedWithXMLCoder">YES</bool>
-																<object class="NSTableView" id="23853726">
-																	<reference key="NSNextResponder" ref="119083427"/>
-																	<int key="NSvFlags">256</int>
-																	<string key="NSFrameSize">{156, 200}</string>
-																	<reference key="NSSuperview" ref="119083427"/>
-																	<reference key="NSWindow"/>
-																	<bool key="NSEnabled">YES</bool>
-																	<object class="NSTableHeaderView" key="NSHeaderView" id="1048357090">
-																		<reference key="NSNextResponder" ref="746968320"/>
-																		<int key="NSvFlags">256</int>
-																		<string key="NSFrameSize">{156, 17}</string>
-																		<reference key="NSSuperview" ref="746968320"/>
-																		<reference key="NSWindow"/>
-																		<reference key="NSTableView" ref="23853726"/>
-																	</object>
-																	<object class="_NSCornerView" key="NSCornerView" id="212282722">
-																		<reference key="NSNextResponder" ref="516244966"/>
-																		<int key="NSvFlags">256</int>
-																		<string key="NSFrame">{{157, 0}, {16, 17}}</string>
-																		<reference key="NSSuperview" ref="516244966"/>
-																		<reference key="NSWindow"/>
-																	</object>
-																	<object class="NSMutableArray" key="NSTableColumns">
-																		<bool key="EncodedWithXMLCoder">YES</bool>
-																		<object class="NSTableColumn" id="920426212">
-																			<double key="NSWidth">7.100000e+01</double>
-																			<double key="NSMinWidth">4.000000e+01</double>
-																			<double key="NSMaxWidth">1.000000e+03</double>
-																			<object class="NSTableHeaderCell" key="NSHeaderCell">
-																				<int key="NSCellFlags">75628032</int>
-																				<int key="NSCellFlags2">0</int>
-																				<string key="NSContents">Variable</string>
-																				<reference key="NSSupport" ref="26"/>
-																				<object class="NSColor" key="NSBackgroundColor" id="890615311">
-																					<int key="NSColorSpace">3</int>
-																					<bytes key="NSWhite">MC4zMzMzMzI5OQA</bytes>
-																				</object>
-																				<object class="NSColor" key="NSTextColor" id="866628999">
-																					<int key="NSColorSpace">6</int>
-																					<reference key="NSCatalogName" ref="484387293"/>
-																					<string key="NSColorName">headerTextColor</string>
-																					<reference key="NSColor" ref="555789289"/>
-																				</object>
-																			</object>
-																			<object class="NSTextFieldCell" key="NSDataCell" id="525071236">
-																				<int key="NSCellFlags">337772096</int>
-																				<int key="NSCellFlags2">2048</int>
-																				<string key="NSContents" id="456204663">Text Cell</string>
-																				<object class="NSFont" key="NSSupport" id="8196371">
-																					<reference key="NSName" ref="378950370"/>
-																					<double key="NSSize">1.300000e+01</double>
-																					<int key="NSfFlags">1044</int>
-																				</object>
-																				<reference key="NSControlView" ref="23853726"/>
-																				<object class="NSColor" key="NSBackgroundColor" id="224028609">
-																					<int key="NSColorSpace">6</int>
-																					<reference key="NSCatalogName" ref="484387293"/>
-																					<string key="NSColorName">controlBackgroundColor</string>
-																					<reference key="NSColor" ref="377165725"/>
-																				</object>
-																				<object class="NSColor" key="NSTextColor" id="205104690">
-																					<int key="NSColorSpace">6</int>
-																					<reference key="NSCatalogName" ref="484387293"/>
-																					<string key="NSColorName">controlTextColor</string>
-																					<reference key="NSColor" ref="555789289"/>
-																				</object>
-																			</object>
-																			<int key="NSResizingMask">3</int>
-																			<bool key="NSIsResizeable">YES</bool>
-																			<bool key="NSIsEditable">YES</bool>
-																			<reference key="NSTableView" ref="23853726"/>
-																		</object>
-																		<object class="NSTableColumn" id="857054683">
-																			<double key="NSWidth">7.900000e+01</double>
-																			<double key="NSMinWidth">4.000000e+01</double>
-																			<double key="NSMaxWidth">1.000000e+03</double>
-																			<object class="NSTableHeaderCell" key="NSHeaderCell">
-																				<int key="NSCellFlags">75628032</int>
-																				<int key="NSCellFlags2">0</int>
-																				<string key="NSContents">Value</string>
-																				<reference key="NSSupport" ref="26"/>
-																				<reference key="NSBackgroundColor" ref="890615311"/>
-																				<reference key="NSTextColor" ref="866628999"/>
-																			</object>
-																			<object class="NSTextFieldCell" key="NSDataCell" id="377147224">
-																				<int key="NSCellFlags">337772096</int>
-																				<int key="NSCellFlags2">2048</int>
-																				<reference key="NSContents" ref="456204663"/>
-																				<reference key="NSSupport" ref="8196371"/>
-																				<reference key="NSControlView" ref="23853726"/>
-																				<reference key="NSBackgroundColor" ref="224028609"/>
-																				<reference key="NSTextColor" ref="205104690"/>
-																			</object>
-																			<int key="NSResizingMask">3</int>
-																			<bool key="NSIsResizeable">YES</bool>
-																			<bool key="NSIsEditable">YES</bool>
-																			<reference key="NSTableView" ref="23853726"/>
-																		</object>
-																	</object>
-																	<double key="NSIntercellSpacingWidth">3.000000e+00</double>
-																	<double key="NSIntercellSpacingHeight">2.000000e+00</double>
-																	<reference key="NSBackgroundColor" ref="521347521"/>
-																	<object class="NSColor" key="NSGridColor">
-																		<int key="NSColorSpace">6</int>
-																		<reference key="NSCatalogName" ref="484387293"/>
-																		<string key="NSColorName">gridColor</string>
-																		<object class="NSColor" key="NSColor">
-																			<int key="NSColorSpace">3</int>
-																			<bytes key="NSWhite">MC41AA</bytes>
-																		</object>
-																	</object>
-																	<double key="NSRowHeight">1.700000e+01</double>
-																	<int key="NSTvFlags">-692060160</int>
-																	<int key="NSGridStyleMask">1</int>
-																	<int key="NSColumnAutoresizingStyle">4</int>
-																	<int key="NSDraggingSourceMaskForLocal">15</int>
-																	<int key="NSDraggingSourceMaskForNonLocal">0</int>
-																	<bool key="NSAllowsTypeSelect">YES</bool>
-																</object>
-															</object>
-															<string key="NSFrame">{{1, 17}, {156, 200}}</string>
-															<reference key="NSSuperview" ref="516244966"/>
-															<reference key="NSWindow"/>
-															<reference key="NSNextKeyView" ref="23853726"/>
-															<reference key="NSDocView" ref="23853726"/>
-															<reference key="NSBGColor" ref="224028609"/>
-															<int key="NScvFlags">4</int>
-														</object>
-														<object class="NSScroller" id="512953560">
-															<reference key="NSNextResponder" ref="516244966"/>
-															<int key="NSvFlags">256</int>
-															<string key="NSFrame">{{157, 17}, {15, 200}}</string>
-															<reference key="NSSuperview" ref="516244966"/>
-															<reference key="NSWindow"/>
-															<reference key="NSTarget" ref="516244966"/>
-															<reference key="NSAction" ref="688920982"/>
-															<double key="NSPercent">9.961240e-01</double>
-														</object>
-														<object class="NSScroller" id="47103270">
-															<reference key="NSNextResponder" ref="516244966"/>
-															<int key="NSvFlags">256</int>
-															<string key="NSFrame">{{1, 217}, {156, 15}}</string>
-															<reference key="NSSuperview" ref="516244966"/>
-															<reference key="NSWindow"/>
-															<int key="NSsFlags">1</int>
-															<reference key="NSTarget" ref="516244966"/>
-															<reference key="NSAction" ref="688920982"/>
-															<double key="NSPercent">7.179487e-01</double>
-														</object>
-														<object class="NSClipView" id="746968320">
-															<reference key="NSNextResponder" ref="516244966"/>
-															<int key="NSvFlags">2304</int>
-															<object class="NSMutableArray" key="NSSubviews">
-																<bool key="EncodedWithXMLCoder">YES</bool>
-																<reference ref="1048357090"/>
-															</object>
-															<string key="NSFrame">{{1, 0}, {156, 17}}</string>
-															<reference key="NSSuperview" ref="516244966"/>
-															<reference key="NSWindow"/>
-															<reference key="NSNextKeyView" ref="1048357090"/>
-															<reference key="NSDocView" ref="1048357090"/>
-															<reference key="NSBGColor" ref="224028609"/>
-															<int key="NScvFlags">4</int>
-														</object>
-														<reference ref="212282722"/>
-													</object>
-													<string key="NSFrame">{{18, 14}, {173, 233}}</string>
-													<reference key="NSSuperview" ref="581281551"/>
-													<reference key="NSWindow"/>
-													<reference key="NSNextKeyView" ref="119083427"/>
-													<int key="NSsFlags">50</int>
-													<reference key="NSVScroller" ref="512953560"/>
-													<reference key="NSHScroller" ref="47103270"/>
-													<reference key="NSContentView" ref="119083427"/>
-													<reference key="NSHeaderClipView" ref="746968320"/>
-													<reference key="NSCornerView" ref="212282722"/>
-													<bytes key="NSScrollAmts">QSAAAEEgAABBmAAAQZgAAA</bytes>
-												</object>
-											</object>
-											<string key="NSFrame">{{1, 1}, {209, 257}}</string>
-											<reference key="NSSuperview" ref="764100755"/>
-											<reference key="NSWindow"/>
-										</object>
-									</object>
-									<string key="NSFrame">{{474, 0}, {211, 273}}</string>
-									<reference key="NSSuperview" ref="741760375"/>
-									<reference key="NSWindow"/>
-									<reference key="NSOffsets" ref="1055927954"/>
-									<object class="NSTextFieldCell" key="NSTitleCell">
-										<int key="NSCellFlags">67239424</int>
-										<int key="NSCellFlags2">0</int>
-										<string key="NSContents">Workspace</string>
-										<reference key="NSSupport" ref="26"/>
-										<reference key="NSBackgroundColor" ref="131515055"/>
-										<object class="NSColor" key="NSTextColor">
-											<int key="NSColorSpace">3</int>
-											<bytes key="NSWhite">MCAwLjgwMDAwMDAxAA</bytes>
-										</object>
-									</object>
-									<reference key="NSContentView" ref="581281551"/>
-									<int key="NSBorderType">1</int>
-									<int key="NSBoxType">0</int>
-									<int key="NSTitlePosition">2</int>
-									<bool key="NSTransparent">NO</bool>
-								</object>
-							</object>
-							<string key="NSFrame">{{20, 44}, {685, 273}}</string>
-							<reference key="NSSuperview" ref="439893737"/>
-							<reference key="NSWindow"/>
-							<bool key="NSIsVertical">YES</bool>
-							<int key="NSDividerStyle">2</int>
-							<string key="NSAutosaveName">ipython1_console_workspace_split</string>
-						</object>
-						<object class="NSProgressIndicator" id="74807016">
-							<reference key="NSNextResponder" ref="439893737"/>
-							<int key="NSvFlags">1313</int>
-							<object class="NSPSMatrix" key="NSDrawMatrix"/>
-							<string key="NSFrame">{{689, 20}, {16, 16}}</string>
-							<reference key="NSSuperview" ref="439893737"/>
-							<reference key="NSWindow"/>
-							<int key="NSpiFlags">28938</int>
-							<double key="NSMinValue">1.600000e+01</double>
-							<double key="NSMaxValue">1.000000e+02</double>
-						</object>
-					</object>
-					<string key="NSFrameSize">{725, 337}</string>
-					<reference key="NSSuperview"/>
-					<reference key="NSWindow"/>
-				</object>
-				<string key="NSScreenRect">{{0, 0}, {1280, 778}}</string>
-				<string key="NSFrameAutosaveName">ipython1_sandbox</string>
-			</object>
-			<object class="NSCustomObject" id="610635028">
-				<string key="NSClassName" id="982950837">IPython1SandboxAppDelegate</string>
-			</object>
-			<object class="NSDictionaryController" id="808393665">
-				<object class="NSMutableArray" key="NSDeclaredKeys">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-					<string>keys</string>
-					<string id="181461860">key</string>
-					<string id="276523235">value</string>
-				</object>
-				<bool key="NSEditable">YES</bool>
-				<bool key="NSAvoidsEmptySelection">YES</bool>
-				<bool key="NSPreservesSelection">YES</bool>
-				<bool key="NSSelectsInsertedObjects">YES</bool>
-				<bool key="NSFilterRestrictsInsertion">YES</bool>
-				<object class="NSArray" key="NSSortDescriptors">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-					<object class="NSSortDescriptor">
-						<reference key="NSKey" ref="181461860"/>
-						<bool key="NSAscending">YES</bool>
-						<string key="NSSelector">compare:</string>
-					</object>
-				</object>
-				<bool key="NSClearsFilterPredicateOnInsertion">YES</bool>
-				<reference key="NSInitialKey" ref="181461860"/>
-				<reference key="NSInitialValue" ref="276523235"/>
-			</object>
-			<object class="NSCustomObject" id="631572152">
-				<string key="NSClassName" id="695797635">IPythonCocoaController</string>
-			</object>
-		</object>
-		<object class="IBObjectContainer" key="IBDocument.Objects">
-			<object class="NSMutableArray" key="connectionRecords">
-				<bool key="EncodedWithXMLCoder">YES</bool>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">performMiniaturize:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="1011231497"/>
-					</object>
-					<int key="connectionID">37</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">arrangeInFront:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="625202149"/>
-					</object>
-					<int key="connectionID">39</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">print:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="49223823"/>
-					</object>
-					<int key="connectionID">86</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">runPageLayout:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="294629803"/>
-					</object>
-					<int key="connectionID">87</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">clearRecentDocuments:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="759406840"/>
-					</object>
-					<int key="connectionID">127</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">orderFrontStandardAboutPanel:</string>
-						<reference key="source" ref="1021"/>
-						<reference key="destination" ref="238522557"/>
-					</object>
-					<int key="connectionID">142</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">performClose:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="776162233"/>
-					</object>
-					<int key="connectionID">193</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">toggleContinuousSpellChecking:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="948374510"/>
-					</object>
-					<int key="connectionID">222</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">undo:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="1058277027"/>
-					</object>
-					<int key="connectionID">223</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">copy:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="860595796"/>
-					</object>
-					<int key="connectionID">224</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">checkSpelling:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="96193923"/>
-					</object>
-					<int key="connectionID">225</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">paste:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="29853731"/>
-					</object>
-					<int key="connectionID">226</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">stopSpeaking:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="680220178"/>
-					</object>
-					<int key="connectionID">227</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">cut:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="296257095"/>
-					</object>
-					<int key="connectionID">228</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">showGuessPanel:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="679648819"/>
-					</object>
-					<int key="connectionID">230</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">redo:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="790794224"/>
-					</object>
-					<int key="connectionID">231</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">selectAll:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="583158037"/>
-					</object>
-					<int key="connectionID">232</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">startSpeaking:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="731782645"/>
-					</object>
-					<int key="connectionID">233</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">delete:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="437104165"/>
-					</object>
-					<int key="connectionID">235</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">performZoom:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="575023229"/>
-					</object>
-					<int key="connectionID">240</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">performFindPanelAction:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="447796847"/>
-					</object>
-					<int key="connectionID">241</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">centerSelectionInVisibleArea:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="88285865"/>
-					</object>
-					<int key="connectionID">245</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">toggleGrammarChecking:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="967646866"/>
-					</object>
-					<int key="connectionID">347</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">toggleSmartInsertDelete:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="605118523"/>
-					</object>
-					<int key="connectionID">355</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">toggleAutomaticQuoteSubstitution:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="197661976"/>
-					</object>
-					<int key="connectionID">356</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">toggleAutomaticLinkDetection:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="708854459"/>
-					</object>
-					<int key="connectionID">357</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">showHelp:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="238773614"/>
-					</object>
-					<int key="connectionID">360</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">orderFrontColorPanel:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="1028416764"/>
-					</object>
-					<int key="connectionID">361</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">saveDocument:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="1023925487"/>
-					</object>
-					<int key="connectionID">362</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">saveDocumentAs:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="117038363"/>
-					</object>
-					<int key="connectionID">363</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">revertDocumentToSaved:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="579971712"/>
-					</object>
-					<int key="connectionID">364</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">runToolbarCustomizationPalette:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="237841660"/>
-					</object>
-					<int key="connectionID">365</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">toggleToolbarShown:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="102151532"/>
-					</object>
-					<int key="connectionID">366</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">hide:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="755159360"/>
-					</object>
-					<int key="connectionID">367</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">hideOtherApplications:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="342932134"/>
-					</object>
-					<int key="connectionID">368</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">terminate:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="632727374"/>
-					</object>
-					<int key="connectionID">369</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">unhideAllApplications:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="908899353"/>
-					</object>
-					<int key="connectionID">370</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBOutletConnection" key="connection">
-						<string key="label" id="606168085">delegate</string>
-						<reference key="source" ref="1050"/>
-						<reference key="destination" ref="610635028"/>
-					</object>
-					<int key="connectionID">374</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBBindingConnection" key="connection">
-						<string key="label" id="187454546">contentDictionary: userNS</string>
-						<reference key="source" ref="808393665"/>
-						<reference key="destination" ref="631572152"/>
-						<object class="NSNibBindingConnector" key="connector">
-							<reference key="NSSource" ref="808393665"/>
-							<reference key="NSDestination" ref="631572152"/>
-							<reference key="NSLabel" ref="187454546"/>
-							<string key="NSBinding">contentDictionary</string>
-							<string key="NSKeyPath">userNS</string>
-							<int key="NSNibBindingConnectorVersion">2</int>
-						</object>
-					</object>
-					<int key="connectionID">424</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBBindingConnection" key="connection">
-						<string key="label" id="688370141">value: arrangedObjects.value</string>
-						<reference key="source" ref="857054683"/>
-						<reference key="destination" ref="808393665"/>
-						<object class="NSNibBindingConnector" key="connector">
-							<reference key="NSSource" ref="857054683"/>
-							<reference key="NSDestination" ref="808393665"/>
-							<reference key="NSLabel" ref="688370141"/>
-							<reference key="NSBinding" ref="276523235"/>
-							<string key="NSKeyPath">arrangedObjects.value</string>
-							<int key="NSNibBindingConnectorVersion">2</int>
-						</object>
-					</object>
-					<int key="connectionID">427</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBBindingConnection" key="connection">
-						<string key="label" id="764859820">value: arrangedObjects.key</string>
-						<reference key="source" ref="920426212"/>
-						<reference key="destination" ref="808393665"/>
-						<object class="NSNibBindingConnector" key="connector">
-							<reference key="NSSource" ref="920426212"/>
-							<reference key="NSDestination" ref="808393665"/>
-							<reference key="NSLabel" ref="764859820"/>
-							<reference key="NSBinding" ref="276523235"/>
-							<string key="NSKeyPath">arrangedObjects.key</string>
-							<int key="NSNibBindingConnectorVersion">2</int>
-						</object>
-					</object>
-					<int key="connectionID">428</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBOutletConnection" key="connection">
-						<reference key="label" ref="606168085"/>
-						<reference key="source" ref="972006081"/>
-						<reference key="destination" ref="631572152"/>
-					</object>
-					<int key="connectionID">429</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBBindingConnection" key="connection">
-						<string key="label" id="97087091">animate: waitingForEngine</string>
-						<reference key="source" ref="74807016"/>
-						<reference key="destination" ref="631572152"/>
-						<object class="NSNibBindingConnector" key="connector">
-							<reference key="NSSource" ref="74807016"/>
-							<reference key="NSDestination" ref="631572152"/>
-							<reference key="NSLabel" ref="97087091"/>
-							<string key="NSBinding">animate</string>
-							<string key="NSKeyPath">waitingForEngine</string>
-							<int key="NSNibBindingConnectorVersion">2</int>
-						</object>
-					</object>
-					<int key="connectionID">437</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBBindingConnection" key="connection">
-						<string key="label" id="289275654">filterPredicate: workspaceFilterPredicate</string>
-						<reference key="source" ref="808393665"/>
-						<reference key="destination" ref="610635028"/>
-						<object class="NSNibBindingConnector" key="connector">
-							<reference key="NSSource" ref="808393665"/>
-							<reference key="NSDestination" ref="610635028"/>
-							<reference key="NSLabel" ref="289275654"/>
-							<string key="NSBinding">filterPredicate</string>
-							<string key="NSKeyPath">workspaceFilterPredicate</string>
-							<int key="NSNibBindingConnectorVersion">2</int>
-						</object>
-					</object>
-					<int key="connectionID">440</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBOutletConnection" key="connection">
-						<string key="label">ipythonController</string>
-						<reference key="source" ref="610635028"/>
-						<reference key="destination" ref="631572152"/>
-					</object>
-					<int key="connectionID">441</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBOutletConnection" key="connection">
-						<string key="label" id="684042788">textView</string>
-						<reference key="source" ref="631572152"/>
-						<reference key="destination" ref="163417131"/>
-					</object>
-					<int key="connectionID">444</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBOutletConnection" key="connection">
-						<string key="label">initialFirstResponder</string>
-						<reference key="source" ref="972006081"/>
-						<reference key="destination" ref="163417131"/>
-					</object>
-					<int key="connectionID">445</int>
-				</object>
-			</object>
-			<object class="IBMutableOrderedSet" key="objectRecords">
-				<object class="NSArray" key="orderedObjects">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-					<object class="IBObjectRecord">
-						<int key="objectID">0</int>
-						<object class="NSArray" key="object" id="1049">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-						</object>
-						<reference key="children" ref="1048"/>
-						<nil key="parent"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">-2</int>
-						<reference key="object" ref="1021"/>
-						<reference key="parent" ref="1049"/>
-						<string type="base64-UTF8" key="objectName">RmlsZSdzIE93bmVyA</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">-1</int>
-						<reference key="object" ref="1014"/>
-						<reference key="parent" ref="1049"/>
-						<string key="objectName">First Responder</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">-3</int>
-						<reference key="object" ref="1050"/>
-						<reference key="parent" ref="1049"/>
-						<string key="objectName">Application</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">29</int>
-						<reference key="object" ref="649796088"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="713487014"/>
-							<reference ref="694149608"/>
-							<reference ref="391199113"/>
-							<reference ref="952259628"/>
-							<reference ref="379814623"/>
-							<reference ref="586577488"/>
-							<reference ref="626404410"/>
-						</object>
-						<reference key="parent" ref="1049"/>
-						<string key="objectName">MainMenu</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">19</int>
-						<reference key="object" ref="713487014"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="835318025"/>
-						</object>
-						<reference key="parent" ref="649796088"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">56</int>
-						<reference key="object" ref="694149608"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="110575045"/>
-						</object>
-						<reference key="parent" ref="649796088"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">103</int>
-						<reference key="object" ref="391199113"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="374024848"/>
-						</object>
-						<reference key="parent" ref="649796088"/>
-						<string key="objectName" id="508169456">1</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">217</int>
-						<reference key="object" ref="952259628"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="789758025"/>
-						</object>
-						<reference key="parent" ref="649796088"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">83</int>
-						<reference key="object" ref="379814623"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="720053764"/>
-						</object>
-						<reference key="parent" ref="649796088"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">81</int>
-						<reference key="object" ref="720053764"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="1023925487"/>
-							<reference ref="117038363"/>
-							<reference ref="49223823"/>
-							<reference ref="722745758"/>
-							<reference ref="705341025"/>
-							<reference ref="1025936716"/>
-							<reference ref="294629803"/>
-							<reference ref="776162233"/>
-							<reference ref="425164168"/>
-							<reference ref="579971712"/>
-							<reference ref="1010469920"/>
-						</object>
-						<reference key="parent" ref="379814623"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">75</int>
-						<reference key="object" ref="1023925487"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName">3</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">80</int>
-						<reference key="object" ref="117038363"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName">8</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">78</int>
-						<reference key="object" ref="49223823"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName">6</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">72</int>
-						<reference key="object" ref="722745758"/>
-						<reference key="parent" ref="720053764"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">82</int>
-						<reference key="object" ref="705341025"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName">9</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">124</int>
-						<reference key="object" ref="1025936716"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="1065607017"/>
-						</object>
-						<reference key="parent" ref="720053764"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">77</int>
-						<reference key="object" ref="294629803"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName">5</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">73</int>
-						<reference key="object" ref="776162233"/>
-						<reference key="parent" ref="720053764"/>
-						<reference key="objectName" ref="508169456"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">79</int>
-						<reference key="object" ref="425164168"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName">7</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">112</int>
-						<reference key="object" ref="579971712"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName">10</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">74</int>
-						<reference key="object" ref="1010469920"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName" id="464456376">2</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">125</int>
-						<reference key="object" ref="1065607017"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="759406840"/>
-						</object>
-						<reference key="parent" ref="1025936716"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">126</int>
-						<reference key="object" ref="759406840"/>
-						<reference key="parent" ref="1065607017"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">205</int>
-						<reference key="object" ref="789758025"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="437104165"/>
-							<reference ref="583158037"/>
-							<reference ref="1058277027"/>
-							<reference ref="212016141"/>
-							<reference ref="296257095"/>
-							<reference ref="29853731"/>
-							<reference ref="860595796"/>
-							<reference ref="1040322652"/>
-							<reference ref="790794224"/>
-							<reference ref="892235320"/>
-							<reference ref="972420730"/>
-							<reference ref="676164635"/>
-							<reference ref="507821607"/>
-						</object>
-						<reference key="parent" ref="952259628"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">202</int>
-						<reference key="object" ref="437104165"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">198</int>
-						<reference key="object" ref="583158037"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">207</int>
-						<reference key="object" ref="1058277027"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">214</int>
-						<reference key="object" ref="212016141"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">199</int>
-						<reference key="object" ref="296257095"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">203</int>
-						<reference key="object" ref="29853731"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">197</int>
-						<reference key="object" ref="860595796"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">206</int>
-						<reference key="object" ref="1040322652"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">215</int>
-						<reference key="object" ref="790794224"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">218</int>
-						<reference key="object" ref="892235320"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="963351320"/>
-						</object>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">216</int>
-						<reference key="object" ref="972420730"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="769623530"/>
-						</object>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">200</int>
-						<reference key="object" ref="769623530"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="948374510"/>
-							<reference ref="96193923"/>
-							<reference ref="679648819"/>
-							<reference ref="967646866"/>
-						</object>
-						<reference key="parent" ref="972420730"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">219</int>
-						<reference key="object" ref="948374510"/>
-						<reference key="parent" ref="769623530"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">201</int>
-						<reference key="object" ref="96193923"/>
-						<reference key="parent" ref="769623530"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">204</int>
-						<reference key="object" ref="679648819"/>
-						<reference key="parent" ref="769623530"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">220</int>
-						<reference key="object" ref="963351320"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="270902937"/>
-							<reference ref="88285865"/>
-							<reference ref="159080638"/>
-							<reference ref="326711663"/>
-							<reference ref="447796847"/>
-						</object>
-						<reference key="parent" ref="892235320"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">213</int>
-						<reference key="object" ref="270902937"/>
-						<reference key="parent" ref="963351320"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">210</int>
-						<reference key="object" ref="88285865"/>
-						<reference key="parent" ref="963351320"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">221</int>
-						<reference key="object" ref="159080638"/>
-						<reference key="parent" ref="963351320"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">208</int>
-						<reference key="object" ref="326711663"/>
-						<reference key="parent" ref="963351320"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">209</int>
-						<reference key="object" ref="447796847"/>
-						<reference key="parent" ref="963351320"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">106</int>
-						<reference key="object" ref="374024848"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="238773614"/>
-						</object>
-						<reference key="parent" ref="391199113"/>
-						<reference key="objectName" ref="464456376"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">111</int>
-						<reference key="object" ref="238773614"/>
-						<reference key="parent" ref="374024848"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">57</int>
-						<reference key="object" ref="110575045"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="238522557"/>
-							<reference ref="755159360"/>
-							<reference ref="908899353"/>
-							<reference ref="632727374"/>
-							<reference ref="646227648"/>
-							<reference ref="609285721"/>
-							<reference ref="481834944"/>
-							<reference ref="304266470"/>
-							<reference ref="1046388886"/>
-							<reference ref="1056857174"/>
-							<reference ref="342932134"/>
-						</object>
-						<reference key="parent" ref="694149608"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">58</int>
-						<reference key="object" ref="238522557"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">134</int>
-						<reference key="object" ref="755159360"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">150</int>
-						<reference key="object" ref="908899353"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">136</int>
-						<reference key="object" ref="632727374"/>
-						<reference key="parent" ref="110575045"/>
-						<string key="objectName">1111</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">144</int>
-						<reference key="object" ref="646227648"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">129</int>
-						<reference key="object" ref="609285721"/>
-						<reference key="parent" ref="110575045"/>
-						<string key="objectName">121</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">143</int>
-						<reference key="object" ref="481834944"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">236</int>
-						<reference key="object" ref="304266470"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">131</int>
-						<reference key="object" ref="1046388886"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="752062318"/>
-						</object>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">149</int>
-						<reference key="object" ref="1056857174"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">145</int>
-						<reference key="object" ref="342932134"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">130</int>
-						<reference key="object" ref="752062318"/>
-						<reference key="parent" ref="1046388886"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">24</int>
-						<reference key="object" ref="835318025"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="299356726"/>
-							<reference ref="625202149"/>
-							<reference ref="575023229"/>
-							<reference ref="1011231497"/>
-						</object>
-						<reference key="parent" ref="713487014"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">92</int>
-						<reference key="object" ref="299356726"/>
-						<reference key="parent" ref="835318025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">5</int>
-						<reference key="object" ref="625202149"/>
-						<reference key="parent" ref="835318025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">239</int>
-						<reference key="object" ref="575023229"/>
-						<reference key="parent" ref="835318025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">23</int>
-						<reference key="object" ref="1011231497"/>
-						<reference key="parent" ref="835318025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">295</int>
-						<reference key="object" ref="586577488"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="466310130"/>
-						</object>
-						<reference key="parent" ref="649796088"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">296</int>
-						<reference key="object" ref="466310130"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="102151532"/>
-							<reference ref="237841660"/>
-						</object>
-						<reference key="parent" ref="586577488"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">297</int>
-						<reference key="object" ref="102151532"/>
-						<reference key="parent" ref="466310130"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">298</int>
-						<reference key="object" ref="237841660"/>
-						<reference key="parent" ref="466310130"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">299</int>
-						<reference key="object" ref="626404410"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="502084290"/>
-						</object>
-						<reference key="parent" ref="649796088"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">300</int>
-						<reference key="object" ref="502084290"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="519768076"/>
-							<reference ref="1028416764"/>
-						</object>
-						<reference key="parent" ref="626404410"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">344</int>
-						<reference key="object" ref="519768076"/>
-						<reference key="parent" ref="502084290"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">345</int>
-						<reference key="object" ref="1028416764"/>
-						<reference key="parent" ref="502084290"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">211</int>
-						<reference key="object" ref="676164635"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="785027613"/>
-						</object>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">212</int>
-						<reference key="object" ref="785027613"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="680220178"/>
-							<reference ref="731782645"/>
-						</object>
-						<reference key="parent" ref="676164635"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">195</int>
-						<reference key="object" ref="680220178"/>
-						<reference key="parent" ref="785027613"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">196</int>
-						<reference key="object" ref="731782645"/>
-						<reference key="parent" ref="785027613"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">346</int>
-						<reference key="object" ref="967646866"/>
-						<reference key="parent" ref="769623530"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">348</int>
-						<reference key="object" ref="507821607"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="698887838"/>
-						</object>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">349</int>
-						<reference key="object" ref="698887838"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="605118523"/>
-							<reference ref="197661976"/>
-							<reference ref="708854459"/>
-						</object>
-						<reference key="parent" ref="507821607"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">350</int>
-						<reference key="object" ref="605118523"/>
-						<reference key="parent" ref="698887838"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">351</int>
-						<reference key="object" ref="197661976"/>
-						<reference key="parent" ref="698887838"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">354</int>
-						<reference key="object" ref="708854459"/>
-						<reference key="parent" ref="698887838"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">371</int>
-						<reference key="object" ref="972006081"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="439893737"/>
-						</object>
-						<reference key="parent" ref="1049"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">372</int>
-						<reference key="object" ref="439893737"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="741760375"/>
-							<reference ref="74807016"/>
-						</object>
-						<reference key="parent" ref="972006081"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">373</int>
-						<reference key="object" ref="610635028"/>
-						<reference key="parent" ref="1049"/>
-						<reference key="objectName" ref="982950837"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">385</int>
-						<reference key="object" ref="808393665"/>
-						<reference key="parent" ref="1049"/>
-						<string key="objectName">User Namespace Controller</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">421</int>
-						<reference key="object" ref="741760375"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="554641139"/>
-							<reference ref="764100755"/>
-						</object>
-						<reference key="parent" ref="439893737"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">420</int>
-						<reference key="object" ref="554641139"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="188193463"/>
-						</object>
-						<reference key="parent" ref="741760375"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">416</int>
-						<reference key="object" ref="188193463"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="418410897"/>
-							<reference ref="936733673"/>
-							<reference ref="163417131"/>
-						</object>
-						<reference key="parent" ref="554641139"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">417</int>
-						<reference key="object" ref="418410897"/>
-						<reference key="parent" ref="188193463"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">418</int>
-						<reference key="object" ref="936733673"/>
-						<reference key="parent" ref="188193463"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">419</int>
-						<reference key="object" ref="163417131"/>
-						<reference key="parent" ref="188193463"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">406</int>
-						<reference key="object" ref="764100755"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="516244966"/>
-						</object>
-						<reference key="parent" ref="741760375"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">407</int>
-						<reference key="object" ref="516244966"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="23853726"/>
-							<reference ref="47103270"/>
-							<reference ref="512953560"/>
-							<reference ref="1048357090"/>
-						</object>
-						<reference key="parent" ref="764100755"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">411</int>
-						<reference key="object" ref="23853726"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="857054683"/>
-							<reference ref="920426212"/>
-						</object>
-						<reference key="parent" ref="516244966"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">410</int>
-						<reference key="object" ref="47103270"/>
-						<reference key="parent" ref="516244966"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">409</int>
-						<reference key="object" ref="512953560"/>
-						<reference key="parent" ref="516244966"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">408</int>
-						<reference key="object" ref="1048357090"/>
-						<reference key="parent" ref="516244966"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">413</int>
-						<reference key="object" ref="857054683"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="377147224"/>
-						</object>
-						<reference key="parent" ref="23853726"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">412</int>
-						<reference key="object" ref="920426212"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="525071236"/>
-						</object>
-						<reference key="parent" ref="23853726"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">415</int>
-						<reference key="object" ref="525071236"/>
-						<reference key="parent" ref="920426212"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">414</int>
-						<reference key="object" ref="377147224"/>
-						<reference key="parent" ref="857054683"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">422</int>
-						<reference key="object" ref="631572152"/>
-						<reference key="parent" ref="1049"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">436</int>
-						<reference key="object" ref="74807016"/>
-						<reference key="parent" ref="439893737"/>
-					</object>
-				</object>
-			</object>
-			<object class="NSMutableDictionary" key="flattenedProperties">
-				<bool key="EncodedWithXMLCoder">YES</bool>
-				<object class="NSMutableArray" key="dict.sortedKeys">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-					<string>-1.IBPluginDependency</string>
-					<string>-2.IBPluginDependency</string>
-					<string>-3.IBPluginDependency</string>
-					<string>103.IBPluginDependency</string>
-					<string>103.ImportedFromIB2</string>
-					<string>106.IBPluginDependency</string>
-					<string>106.ImportedFromIB2</string>
-					<string>106.editorWindowContentRectSynchronizationRect</string>
-					<string>111.IBPluginDependency</string>
-					<string>111.ImportedFromIB2</string>
-					<string>112.IBPluginDependency</string>
-					<string>112.ImportedFromIB2</string>
-					<string>124.IBPluginDependency</string>
-					<string>124.ImportedFromIB2</string>
-					<string>125.IBPluginDependency</string>
-					<string>125.ImportedFromIB2</string>
-					<string>125.editorWindowContentRectSynchronizationRect</string>
-					<string>126.IBPluginDependency</string>
-					<string>126.ImportedFromIB2</string>
-					<string>129.IBPluginDependency</string>
-					<string>129.ImportedFromIB2</string>
-					<string>130.IBPluginDependency</string>
-					<string>130.ImportedFromIB2</string>
-					<string>130.editorWindowContentRectSynchronizationRect</string>
-					<string>131.IBPluginDependency</string>
-					<string>131.ImportedFromIB2</string>
-					<string>134.IBPluginDependency</string>
-					<string>134.ImportedFromIB2</string>
-					<string>136.IBPluginDependency</string>
-					<string>136.ImportedFromIB2</string>
-					<string>143.IBPluginDependency</string>
-					<string>143.ImportedFromIB2</string>
-					<string>144.IBPluginDependency</string>
-					<string>144.ImportedFromIB2</string>
-					<string>145.IBPluginDependency</string>
-					<string>145.ImportedFromIB2</string>
-					<string>149.IBPluginDependency</string>
-					<string>149.ImportedFromIB2</string>
-					<string>150.IBPluginDependency</string>
-					<string>150.ImportedFromIB2</string>
-					<string>19.IBPluginDependency</string>
-					<string>19.ImportedFromIB2</string>
-					<string>195.IBPluginDependency</string>
-					<string>195.ImportedFromIB2</string>
-					<string>196.IBPluginDependency</string>
-					<string>196.ImportedFromIB2</string>
-					<string>197.IBPluginDependency</string>
-					<string>197.ImportedFromIB2</string>
-					<string>198.IBPluginDependency</string>
-					<string>198.ImportedFromIB2</string>
-					<string>199.IBPluginDependency</string>
-					<string>199.ImportedFromIB2</string>
-					<string>200.IBPluginDependency</string>
-					<string>200.ImportedFromIB2</string>
-					<string>200.editorWindowContentRectSynchronizationRect</string>
-					<string>201.IBPluginDependency</string>
-					<string>201.ImportedFromIB2</string>
-					<string>202.IBPluginDependency</string>
-					<string>202.ImportedFromIB2</string>
-					<string>203.IBPluginDependency</string>
-					<string>203.ImportedFromIB2</string>
-					<string>204.IBPluginDependency</string>
-					<string>204.ImportedFromIB2</string>
-					<string>205.IBPluginDependency</string>
-					<string>205.ImportedFromIB2</string>
-					<string>205.editorWindowContentRectSynchronizationRect</string>
-					<string>206.IBPluginDependency</string>
-					<string>206.ImportedFromIB2</string>
-					<string>207.IBPluginDependency</string>
-					<string>207.ImportedFromIB2</string>
-					<string>208.IBPluginDependency</string>
-					<string>208.ImportedFromIB2</string>
-					<string>209.IBPluginDependency</string>
-					<string>209.ImportedFromIB2</string>
-					<string>210.IBPluginDependency</string>
-					<string>210.ImportedFromIB2</string>
-					<string>211.IBPluginDependency</string>
-					<string>211.ImportedFromIB2</string>
-					<string>212.IBPluginDependency</string>
-					<string>212.ImportedFromIB2</string>
-					<string>212.editorWindowContentRectSynchronizationRect</string>
-					<string>213.IBPluginDependency</string>
-					<string>213.ImportedFromIB2</string>
-					<string>214.IBPluginDependency</string>
-					<string>214.ImportedFromIB2</string>
-					<string>215.IBPluginDependency</string>
-					<string>215.ImportedFromIB2</string>
-					<string>216.IBPluginDependency</string>
-					<string>216.ImportedFromIB2</string>
-					<string>217.IBPluginDependency</string>
-					<string>217.ImportedFromIB2</string>
-					<string>218.IBPluginDependency</string>
-					<string>218.ImportedFromIB2</string>
-					<string>219.IBPluginDependency</string>
-					<string>219.ImportedFromIB2</string>
-					<string>220.IBPluginDependency</string>
-					<string>220.ImportedFromIB2</string>
-					<string>220.editorWindowContentRectSynchronizationRect</string>
-					<string>221.IBPluginDependency</string>
-					<string>221.ImportedFromIB2</string>
-					<string>23.IBPluginDependency</string>
-					<string>23.ImportedFromIB2</string>
-					<string>236.IBPluginDependency</string>
-					<string>236.ImportedFromIB2</string>
-					<string>239.IBPluginDependency</string>
-					<string>239.ImportedFromIB2</string>
-					<string>24.IBPluginDependency</string>
-					<string>24.ImportedFromIB2</string>
-					<string>24.editorWindowContentRectSynchronizationRect</string>
-					<string>29.IBPluginDependency</string>
-					<string>29.ImportedFromIB2</string>
-					<string>29.WindowOrigin</string>
-					<string>29.editorWindowContentRectSynchronizationRect</string>
-					<string>295.IBPluginDependency</string>
-					<string>296.IBPluginDependency</string>
-					<string>296.editorWindowContentRectSynchronizationRect</string>
-					<string>297.IBPluginDependency</string>
-					<string>298.IBPluginDependency</string>
-					<string>299.IBPluginDependency</string>
-					<string>300.IBPluginDependency</string>
-					<string>300.editorWindowContentRectSynchronizationRect</string>
-					<string>344.IBPluginDependency</string>
-					<string>345.IBPluginDependency</string>
-					<string>346.IBPluginDependency</string>
-					<string>346.ImportedFromIB2</string>
-					<string>348.IBPluginDependency</string>
-					<string>348.ImportedFromIB2</string>
-					<string>349.IBPluginDependency</string>
-					<string>349.ImportedFromIB2</string>
-					<string>349.editorWindowContentRectSynchronizationRect</string>
-					<string>350.IBPluginDependency</string>
-					<string>350.ImportedFromIB2</string>
-					<string>351.IBPluginDependency</string>
-					<string>351.ImportedFromIB2</string>
-					<string>354.IBPluginDependency</string>
-					<string>354.ImportedFromIB2</string>
-					<string>371.IBPluginDependency</string>
-					<string>371.IBViewEditorWindowController.showingLayoutRectangles</string>
-					<string>371.IBWindowTemplateEditedContentRect</string>
-					<string>371.NSWindowTemplate.visibleAtLaunch</string>
-					<string>371.editorWindowContentRectSynchronizationRect</string>
-					<string>372.IBPluginDependency</string>
-					<string>373.IBPluginDependency</string>
-					<string>385.IBPluginDependency</string>
-					<string>407.IBPluginDependency</string>
-					<string>409.IBPluginDependency</string>
-					<string>410.IBPluginDependency</string>
-					<string>411.IBPluginDependency</string>
-					<string>412.IBPluginDependency</string>
-					<string>413.IBPluginDependency</string>
-					<string>414.IBPluginDependency</string>
-					<string>415.IBPluginDependency</string>
-					<string>416.IBPluginDependency</string>
-					<string>417.IBPluginDependency</string>
-					<string>418.IBPluginDependency</string>
-					<string>419.IBAttributePlaceholdersKey</string>
-					<string>419.IBPluginDependency</string>
-					<string>422.IBPluginDependency</string>
-					<string>436.IBPluginDependency</string>
-					<string>5.IBPluginDependency</string>
-					<string>5.ImportedFromIB2</string>
-					<string>56.IBPluginDependency</string>
-					<string>56.ImportedFromIB2</string>
-					<string>57.IBPluginDependency</string>
-					<string>57.ImportedFromIB2</string>
-					<string>57.editorWindowContentRectSynchronizationRect</string>
-					<string>58.IBPluginDependency</string>
-					<string>58.ImportedFromIB2</string>
-					<string>72.IBPluginDependency</string>
-					<string>72.ImportedFromIB2</string>
-					<string>73.IBPluginDependency</string>
-					<string>73.ImportedFromIB2</string>
-					<string>74.IBPluginDependency</string>
-					<string>74.ImportedFromIB2</string>
-					<string>75.IBPluginDependency</string>
-					<string>75.ImportedFromIB2</string>
-					<string>77.IBPluginDependency</string>
-					<string>77.ImportedFromIB2</string>
-					<string>78.IBPluginDependency</string>
-					<string>78.ImportedFromIB2</string>
-					<string>79.IBPluginDependency</string>
-					<string>79.ImportedFromIB2</string>
-					<string>80.IBPluginDependency</string>
-					<string>80.ImportedFromIB2</string>
-					<string>81.IBPluginDependency</string>
-					<string>81.ImportedFromIB2</string>
-					<string>81.editorWindowContentRectSynchronizationRect</string>
-					<string>82.IBPluginDependency</string>
-					<string>82.ImportedFromIB2</string>
-					<string>83.IBPluginDependency</string>
-					<string>83.ImportedFromIB2</string>
-					<string>92.IBPluginDependency</string>
-					<string>92.ImportedFromIB2</string>
-				</object>
-				<object class="NSMutableArray" key="dict.values">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-					<reference ref="113577022"/>
-					<reference ref="885801228"/>
-					<reference ref="885801228"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{596, 852}, {216, 23}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{522, 812}, {146, 23}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{436, 809}, {64, 6}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{608, 612}, {275, 83}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{365, 632}, {243, 243}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{608, 612}, {167, 43}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{608, 612}, {241, 103}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{525, 802}, {197, 73}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{74, 862}</string>
-					<string>{{11, 736}, {489, 20}}</string>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<string>{{475, 832}, {234, 43}}</string>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<string>{{409, 832}, {176, 43}}</string>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{608, 612}, {215, 63}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<integer value="0"/>
-					<string>{{27, 368}, {725, 337}}</string>
-					<reference ref="9"/>
-					<string>{{27, 368}, {725, 337}}</string>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<object class="NSMutableDictionary">
-						<bool key="EncodedWithXMLCoder">YES</bool>
-						<object class="NSArray" key="dict.sortedKeys">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-						</object>
-						<object class="NSMutableArray" key="dict.values">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-						</object>
-					</object>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{23, 794}, {245, 183}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{323, 672}, {199, 203}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-				</object>
-			</object>
-			<object class="NSMutableDictionary" key="unlocalizedProperties">
-				<bool key="EncodedWithXMLCoder">YES</bool>
-				<object class="NSArray" key="dict.sortedKeys">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-				</object>
-				<object class="NSMutableArray" key="dict.values">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-				</object>
-			</object>
-			<nil key="activeLocalization"/>
-			<object class="NSMutableDictionary" key="localizations">
-				<bool key="EncodedWithXMLCoder">YES</bool>
-				<object class="NSArray" key="dict.sortedKeys">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-				</object>
-				<object class="NSMutableArray" key="dict.values">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-				</object>
-			</object>
-			<nil key="sourceID"/>
-			<int key="maxID">445</int>
-		</object>
-		<object class="IBClassDescriber" key="IBDocument.Classes">
-			<object class="NSMutableArray" key="referencedPartialClassDescriptions">
-				<bool key="EncodedWithXMLCoder">YES</bool>
-				<object class="IBPartialClassDescription">
-					<reference key="className" ref="695797635"/>
-					<nil key="superclassName"/>
-					<object class="NSMutableDictionary" key="actions">
-						<bool key="EncodedWithXMLCoder">YES</bool>
-						<object class="NSArray" key="dict.sortedKeys">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-						</object>
-						<object class="NSMutableArray" key="dict.values">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-						</object>
-					</object>
-					<object class="NSMutableDictionary" key="outlets">
-						<reference key="NS.key.0" ref="684042788"/>
-						<string key="NS.object.0">NSTextView</string>
-					</object>
-					<object class="IBClassDescriptionSource" key="sourceIdentifier">
-						<string key="majorKey">IBUserSource</string>
-						<reference key="minorKey" ref="255189770"/>
-					</object>
-				</object>
-				<object class="IBPartialClassDescription">
-					<string key="className">IPython1SandboxAppDelegate</string>
-					<string key="superclassName">NSObject</string>
-					<object class="NSMutableDictionary" key="actions">
-						<bool key="EncodedWithXMLCoder">YES</bool>
-						<object class="NSArray" key="dict.sortedKeys">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-						</object>
-						<object class="NSMutableArray" key="dict.values">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-						</object>
-					</object>
-					<object class="NSMutableDictionary" key="outlets">
-						<string key="NS.key.0">ipythonController</string>
-						<string key="NS.object.0">id</string>
-					</object>
-					<object class="IBClassDescriptionSource" key="sourceIdentifier">
-						<string key="majorKey">IBProjectSource</string>
-						<string key="minorKey">IPython1SandboxAppDelegate.py</string>
-					</object>
-				</object>
-			</object>
-		</object>
-		<int key="IBDocument.localizationMode">0</int>
-		<string key="IBDocument.LastKnownRelativeProjectPath">../../IPython1Sandbox.xcodeproj</string>
-		<int key="IBDocument.defaultPropertyAccessControl">3</int>
-		<object class="NSMutableData" key="IBDocument.RunnableNib">
-			<bytes key="NS.bytes">YnBsaXN0MDDUAAEAAgADAAQABQAGAAkAClgkdmVyc2lvblQkdG9wWSRhcmNoaXZlclgkb2JqZWN0cxIA
-AYag0QAHAAhdSUIub2JqZWN0ZGF0YYABXxAPTlNLZXllZEFyY2hpdmVyrxEC/gALAAwAMQA1ADYAPAA9
-AEIAWABZAFoAWwALAGgAbQB7AIAAlQCZAKAApAC0ALoAzQDRAOYA+gD7APwA/QD+AP8BAAEBAQIBAwEE
-AQUBBgEHAQgBCQEKAQsBDwEQARkBIQEmASoBLQExATUBOQE7AT0BTQFSAVUBWgFBAVQBYwFqAWsBbAFv
-AXQBdQF4AYAAkAGBAYQBhwGIAYkBjgGPAZABkwGYAZkBmwGeAasBrAGtAbEBvAG9Ab4BwQHCAcQBxQHG
-AdIB0wHbAdwB3wHkAeUB6AHtAfAB/AIAAgcCCwIdAiUCLwIzAlECUgJaAmQCZQJoAm4CbwJyAncCiAKP
-ApACkwKYApkCnAKmAqcCrAKxArICtwK4ArsCwwLJAsoC0QLWAtcC2gLcAt0C5gLnAvAC8QL1AvYC9wL4
-AvkC/wMAAwIDAwMEAwcDFgMYAxsDHAMfAAsDIAMhAyIDJQNXA10DbQNzASkDdAN5A3oDewN+A4IDgwOG
-A4cDiwOPA5YDmgObA5wDnQOhA6gDrAOtA64DrwOzA7wDwAPBA8IDwwPHA84D0gPTA9QD1QPZA+AD5APl
-A+YD6gPxA/UD9gP3A/gD/AQDBAQEBQQJBBAEEQQSBBMEFwQeBB8EIAQkBCsELwQwBDEENQQ9BD4EPwRA
-BEQESwRMBE0ETgRUBFcEWgRbBFwEXwRjBGoEawRsBG0EcgR1BHYEdwR7BIIEgwSEBIUEiQSQBJUElgSX
-BJgEnASjBKQEpQSmBKoEsQSyBLMEtAS4BL8EwwTEBMUExgTKBNEE0gTTBNQE2ATfBOAE4QTiBOYE7QTx
-BPIE8wT0BPgE/wUABQEFBgUNBQ4FDwUTBRwFHQUeBR8FJAUoBS8FMAUxBTIFNwU4BTwFQwVEBUUFRgVK
-BVEFVgVXBVgFXAVjBWQFZQVpBXAFcQVyBXcFeAV8BYMFhAWFBYkFkAWRBZIFlgWdBZ4FnwWjBaoFqwWs
-BbAFtwW4BbkFugW+BcUFxgXHBcgFzAXTBdQF1QXWBeAF9gX8Bf0F/gX/BgMGCwYMBg8GEQYXBhgGGQYa
-Bh0GJAYlBiYGJwYuBi8GMAY3BjgGOQZABkEGQgZDBq0GuAbCBscGyAbJBs4G1QbWBtgG2QbdBt4GyAbn
-BvAGyAbxBvgHAQbIBwIHEgcbByQHLQbIBy4HNgc9Bz4HRQdGB04HTwdQB1kGyAdaB2AHaQbIB2oHbwdw
-B3oHgwbIB4QHkgebB6IHowekB60HtgbIB7cHvAe/B8AHyQfKB9MGyAfUB+IH6QfqB+sH8gfzB/QH/QgG
-CA8GyAgQCBUIHgbICB8IJggvCDAIOQbICDoIPgg/CKkJFAl/CYAJgQmCCYMJhAmFCYYJhwmICYkJigmL
-CYwJjQmOCY8JkAmRCZIJkwmUCZUJlgmXCZgJmQmaCZsJnAmdCZ4JnwmgCaEJogmjCaQJpQmmCacJqAmp
-CaoJqwmsCa0JrgmvCbAJsQmyCbMJtAm1CbYJtwm4CbkJugm7CbwJvQm+Cb8JwAnBCcIJwwnECcUJxgnH
-CcgJyQnKCcsJzAnNCc4JzwnQCdEJ0gnTCdQJ1QnWCdcJ2AnZCdoJ2wncCd0J3gnfCeAJ4QniCeMJ5Anl
-CeYJ6QnsCoYLIAshCyILIwskCyULJgsnCygLKQsqCysLLAstCy4LLwswCzELMgszCzQLNQs2CzcLOAs5
-CzoLOws8Cz0LPgs/C0ALQQtCC0MLRAtFC0YLRwtIC0kLSgtLC0wLTQtOC08LUAtRC1ILUwtUC1ULVgtX
-C1gLWQtaC1sLXAtdC14LXwtgC2ELYgtjC2QLZQtmC2cLaAtpC2oLawtsC20LbgtvC3ALcQtyC3MLdAt1
-C3YLdwt4C3kLegt7C3wLfQt+C38LgAuBC4ILgwuEC4ULhguHC4gLiQuKC4sLjAuNC44LjwuQC5ELkguT
-C5QLlQuWC5cLmAuZC5oLmwucC50LngufC6ALoQuiC6MLpAulC6YLpwuoC6kLqgurC6wLrQuuC68LsAux
-C7ILswu0C7ULtgu3C7oLvQvAVSRudWxs3xASAA0ADgAPABAAEQASABMAFAAVABYAFwAYABkAGgAbABwA
-HQAeAB8AIAAhACIAIwAkACUAJgAnACgAKQAqACsALAAtAC4ALwAwVk5TUm9vdFYkY2xhc3NdTlNPYmpl
-Y3RzS2V5c18QD05TQ2xhc3Nlc1ZhbHVlc18QGU5TQWNjZXNzaWJpbGl0eU9pZHNWYWx1ZXNdTlNDb25u
-ZWN0aW9uc1tOU05hbWVzS2V5c1tOU0ZyYW1ld29ya11OU0NsYXNzZXNLZXlzWk5TT2lkc0tleXNdTlNO
-YW1lc1ZhbHVlc18QGU5TQWNjZXNzaWJpbGl0eUNvbm5lY3RvcnNdTlNGb250TWFuYWdlcl8QEE5TVmlz
-aWJsZVdpbmRvd3NfEA9OU09iamVjdHNWYWx1ZXNfEBdOU0FjY2Vzc2liaWxpdHlPaWRzS2V5c1lOU05l
-eHRPaWRcTlNPaWRzVmFsdWVzgAKBAv2BAZuBAmCBAvyArYEB9oAFgQJfgQJhgQH3gQL6gACABoEB9YEC
-+xEBv4ECYtIADgAyADMANFtOU0NsYXNzTmFtZYAEgANdTlNBcHBsaWNhdGlvbtIANwA4ADkAOlgkY2xh
-c3Nlc1okY2xhc3NuYW1logA6ADteTlNDdXN0b21PYmplY3RYTlNPYmplY3RfEBBJQkNvY29hRnJhbWV3
-b3Jr0gAOAD4APwBAWk5TLm9iamVjdHOAK6EAQYAH2wBDAA4ARABFAEYARwBIAEkASgBLAEwATQBOAE8A
-UABRAFIAUwBUAFUAVgArXE5TV2luZG93Vmlld1xOU1NjcmVlblJlY3RfEBNOU0ZyYW1lQXV0b3NhdmVO
-YW1lXU5TV2luZG93VGl0bGVZTlNXVEZsYWdzXU5TV2luZG93Q2xhc3NcTlNXaW5kb3dSZWN0XxAPTlNX
-aW5kb3dCYWNraW5nXxARTlNXaW5kb3dTdHlsZU1hc2tbTlNWaWV3Q2xhc3OAC4CsgKqAq4AJEnQAAACA
-CoAIEAIQD4AAXxAYe3szMzUsIDQxM30sIHs3MjUsIDMzN319XxAQSVB5dGhvbjEgKENvY29hKVhOU1dp
-bmRvd9cAXAAOAF0AXgBfAFoAYABhAGIAYwBkAGUAYQBnXxAPTlNOZXh0UmVzcG9uZGVyWk5TU3Vidmll
-d3NYTlN2RmxhZ3NbTlNGcmFtZVNpemVbTlNTdXBlcnZpZXeADIBdgA0RAQCAqIAMgKnSAA4APgBpAGqA
-NKIAawBsgA6Ao9oAXAAOAG4AXQBeAG8AcABaAGAAcQBNAHMAdAB1AHYAdwBVAGEATQB6V05TRnJhbWVe
-TlNBdXRvc2F2ZU5hbWVeTlNEaXZpZGVyU3R5bGVcTlNJc1ZlcnRpY2FsgAuAooCggA8RARKAoYAMgAsJ
-0gAOAD4AaQB9gDSiAH4Af4AQgGreAFwAgQAOAIIAgwBdAF4AXwCEAFoAhQCGAGAAhwBrAIkAigCLAIwA
-jQCOAI8AkABhAJIAVQBrAJRZTlNCb3hUeXBlW05TVGl0bGVDZWxsXU5TVHJhbnNwYXJlbnRcTlNCb3Jk
-ZXJUeXBlWU5TT2Zmc2V0c18QD05TVGl0bGVQb3NpdGlvbl1OU0NvbnRlbnRWaWV3gA4QAIBpgGAIgBEQ
-FoBeEAGADIBfgA6AEtIADgA+AGkAl4A0oQCUgBLXAFwADgBuAF0AXgBaAGAAfgBiAJwAnQBkAGEAfoAQ
-gF2AXIATgAyAENIADgA+AGkAooA0oQCjgBTcAFwApQAOAG4ApgBdAF4AWgBgAKcAqACHAJQAqgCrAKwA
-rQCuAHYAYQCUALEAsgCyW05TSFNjcm9sbGVyWE5Tc0ZsYWdzW05TVlNjcm9sbGVyXU5TTmV4dEtleVZp
-ZXeAEoBYgFuAWhECEoAVgAyAEoBUgBaAFtIADgA+AGkAtoA0owCyALEAqoAWgFSAWN0AXAAOAG4AuwC8
-AL0AXQBeAL4AWgC/AGAAqACjAMEAwgDDAMQAxQDGAMcAyABhAMoAowDIWE5TQm91bmRzWE5TQ3Vyc29y
-WU5TY3ZGbGFnc1lOU0RvY1ZpZXdZTlNCR0NvbG9ygBSAU4BNgE6AUBAEgBcRCQCAGIAMgE+AFIAY0gAO
-AD4AaQDPgDShAMiAGN0AXAAOAG4A0gDTANQA1QBeANYAWgDXAGAA2ACyANoA2wDcAN0A3gDfAOAA4QBh
-AOMAsgArXxAPTlNUZXh0Q29udGFpbmVyWU5TVFZGbGFnc1xOU1NoYXJlZERhdGFbTlNEcmFnVHlwZXNZ
-TlNNYXhTaXplWE5TTWluaXplWk5TRGVsZWdhdGWAFoBMgCyALRAGgDeAGREJEoBKgAyAS4AWgADSAA4A
-PgA/AOiAK68QEQDpAOoA6wDsAO0A7gDvAPAA8QDyAPMA9AD1APYA9wD4APmAGoAbgByAHYAegB+AIIAh
-gCKAI4AkgCWAJoAngCiAKYAqXxAZTmVYVCBSVEZEIHBhc3RlYm9hcmQgdHlwZV8QEk5TU3RyaW5nUGJv
-YXJkVHlwZV8QGk5lWFQgcnVsZXIgcGFzdGVib2FyZCB0eXBlXxAeTmVYVCBUSUZGIHY0LjAgcGFzdGVi
-b2FyZCB0eXBlXxAZQXBwbGUgVVJMIHBhc3RlYm9hcmQgdHlwZV8QI0NvcmVQYXN0ZWJvYXJkRmxhdm9y
-VHlwZSAweDZENkY2Rjc2XxAjQ29yZVBhc3RlYm9hcmRGbGF2b3JUeXBlIDB4NzU3MjZDMjBfEBtXZWJV
-UkxzV2l0aFRpdGxlc1Bib2FyZFR5cGVfEBlBcHBsZSBQREYgcGFzdGVib2FyZCB0eXBlXxAZQXBwbGUg
-UE5HIHBhc3RlYm9hcmQgdHlwZV8QGkFwcGxlIEhUTUwgcGFzdGVib2FyZCB0eXBlXxAVTlNGaWxlbmFt
-ZXNQYm9hcmRUeXBlXxAXTlNDb2xvciBwYXN0ZWJvYXJkIHR5cGVfEDFOZVhUIEVuY2Fwc3VsYXRlZCBQ
-b3N0U2NyaXB0IHYxLjIgcGFzdGVib2FyZCB0eXBlXxAaQXBwbGUgUElDVCBwYXN0ZWJvYXJkIHR5cGVf
-EBlOZVhUIGZvbnQgcGFzdGVib2FyZCB0eXBlXxAqTmVYVCBSaWNoIFRleHQgRm9ybWF0IHYxLjAgcGFz
-dGVib2FyZCB0eXBl0gA3ADgBDAENowENAQ4AO1xOU011dGFibGVTZXRVTlNTZXRfEBR7ezAsIDM4fSwg
-ezQzMywgMTR9fdUBEQAOARIBEwEUAJABFQDIARcBGFlOU1RDRmxhZ3NaTlNUZXh0Vmlld1dOU1dpZHRo
-XxAPTlNMYXlvdXRNYW5hZ2VygDaAGCNAexAAAAAAAIAu1QAOARoBGwEcANgBHQEeAR8A3QArXxAQTlNU
-ZXh0Q29udGFpbmVyc11OU1RleHRTdG9yYWdlWU5TTE1GbGFnc4A1gDOAL4AA0wAOASIA2AEjASQAK1hO
-U1N0cmluZ4AygDCAANIADgEnASgBKVlOUy5zdHJpbmeAMVDSADcAOAErASyjASwBIgA7XxAPTlNNdXRh
-YmxlU3RyaW5n0gA3ADgBLgEbpAEbAS8BMAA7XxAZTlNNdXRhYmxlQXR0cmlidXRlZFN0cmluZ18QEk5T
-QXR0cmlidXRlZFN0cmluZ9IADgA+AGkBM4A0oQDcgC3SADcAOAE2ATejATcBOAA7Xk5TTXV0YWJsZUFy
-cmF5V05TQXJyYXnSADcAOAE6ARSiARQAO9IANwA4ATwA0qIA0gA72AAOAT4BPwFAAUEBQgFDAUQBRQFG
-ACsBSAFJAUoAKwFMV05TRmxhZ3NfEBdOU0RlZmF1bHRQYXJhZ3JhcGhTdHlsZV8QEE5TSW5zZXJ0aW9u
-Q29sb3JfEBFOU0JhY2tncm91bmRDb2xvcl8QFE5TU2VsZWN0ZWRBdHRyaWJ1dGVzXxASTlNNYXJrZWRB
-dHRyaWJ1dGVzXxAQTlNMaW5rQXR0cmlidXRlc4BJEgAFS2+AAIA6gDiAO4AAgEXTAA4BTgFPAVAAVQFR
-XE5TQ29sb3JTcGFjZVVOU1JHQoA5TxAYMSAwLjk1Mjk0MTI0IDAuODUwOTgwNDYA0gA3ADgBUwFUogFU
-ADtXTlNDb2xvctMADgFOAVYBUAFYAVlXTlNXaGl0ZYA5EANCMADTAA4BWwA+AVwBXQFgV05TLmtleXOA
-RKIBXgFfgDyAPaIBYQFigD6AQtUADgFUAU4BZAFlAVABZwDdAWgBaVtOU0NvbG9yTmFtZV1OU0NhdGFs
-b2dOYW1lgDmAQYBAgD9WU3lzdGVtXxAbc2VsZWN0ZWRUZXh0QmFja2dyb3VuZENvbG9y0wAOAU4BVgFQ
-AVgBboA5SzAuNjY2NjY2NjkA1QAOAVQBTgFkAWUBUAFIAN0BcgFpgDmAOoBDgD9fEBFzZWxlY3RlZFRl
-eHRDb2xvctIANwA4AXYBd6IBdwA7XE5TRGljdGlvbmFyedMADgFbAD4BXAF6AX2ARKIBewFfgEaAPaIB
-fgF/gEeASFtOU1VuZGVybGluZdMADgFOAU8BUACQAYOAOUYwIDAgMQDSADcAOAGFAYaiAYYAO18QFE5T
-VGV4dFZpZXdTaGFyZWREYXRhXHs0ODAsIDFlKzA3fVd7ODQsIDB90gA3ADgBigESpQESAYsBjAGNADtW
-TlNUZXh0Vk5TVmlld1tOU1Jlc3BvbmRlcl8QFHt7MSwgMX0sIHs0MzMsIDIzMX19XxAVe3swLCAzOH0s
-IHs0MzMsIDIzMX190wAOAU4BVgFQAVgBkoA5QjEA0wAOAZQBlQGWAZcAkFlOU0hvdFNwb3RcTlNDdXJz
-b3JUeXBlgFKAUVd7NCwgLTV90gA3ADgBmgC8ogC8ADvSADcAOAGcAZ2kAZ0BjAGNADtaTlNDbGlwVmll
-d9kAXAGfAA4AbgBeAFoBoABgAaEAowCjAaQBpQGmAGEBqACjAapYTlNUYXJnZXRYTlNBY3Rpb25ZTlNQ
-ZXJjZW50gBSAFIBXgFUT/////4AAAQCADIBWgBQjP9Ww0wAAAABfEBV7ezQyNywgMX0sIHsxNSwgMjYz
-fX1cX2RvU2Nyb2xsZXI60gA3ADgBrgGvpQGvAbABjAGNADtaTlNTY3JvbGxlcllOU0NvbnRyb2zbAFwB
-nwAOAG4ApgBeAFoBoABgAbIBoQCjAKMBpAG2AJAAZABhAagAowG6AbtaTlNDdXJWYWx1ZYAUgBSAV4BZ
-gAyAVoAUIz/wAAAAAAAAIz/uQshgAAAAXxAYe3stMTAwLCAtMTAwfSwgezg3LCAxOH19XxAWe3sxOCwg
-MTR9LCB7NDM1LCAyMzN9fdIANwA4Ab8BwKQBwAGMAY0AO1xOU1Njcm9sbFZpZXdfEBR7ezEsIDF9LCB7
-NDcxLCAyNTd9fdIANwA4AcMBjKMBjAGNADtaezQ3MywgMjczfVZ7MCwgMH3XAccADgFBAcgByQHKAcsB
-zAHNAc4BzwHQAIkB0VtOU0NlbGxGbGFnc1pOU0NvbnRlbnRzWU5TU3VwcG9ydFxOU0NlbGxGbGFnczJb
-TlNUZXh0Q29sb3ISBAH+AIBogGWAYYBigGdXQ29uc29sZdQADgHUAdUB1gHXAdgB2QHaVk5TU2l6ZVZO
-U05hbWVYTlNmRmxhZ3OAZCNAJgAAAAAAAIBjEQwcXEx1Y2lkYUdyYW5kZdIANwA4Ad0B3qIB3gA7Vk5T
-Rm9udNUADgFUAU4BZAFlAVAAygDdAeIBaYA5gE+AZoA/XxATdGV4dEJhY2tncm91bmRDb2xvctMADgFO
-AVYBUAFYAeeAOU0wIDAuODAwMDAwMDEA0gA3ADgB6QHqpAHqAesB7AA7XxAPTlNUZXh0RmllbGRDZWxs
-XE5TQWN0aW9uQ2VsbFZOU0NlbGzSADcAOAHuAe+kAe8BjAGNADtVTlNCb3jeAFwAgQAOAIIAbgCDAF0A
-XgCEAFoAhQCGAGAAhwBrAIkAigHzAfQAjAH2AfcAkABhAJIAVQBrAfuADoBpgJ2AnAiAaxAzgAyAX4AO
-gGzSAA4APgBpAf6ANKEB+4Bs1wBcAA4AbgBdAF4AWgBgAH8AYgIDAgQAZABhAH+AaoBdgJuAbYAMgGrS
-AA4APgBpAgmANKECCoBu3xAPAFwApQAOAG4ApgIMAg0AXQIOAF4AWgBgAKcAqACHAfsCEACrAhICEwIU
-AhUCFgIXAHYAYQH7AhoCGwIbXE5TQ29ybmVyVmlld18QEE5TSGVhZGVyQ2xpcFZpZXdcTlNTY3JvbGxB
-bXRzgGyAloBbgJoQMoB4gHWAb08QEEEgAABBIAAAQZgAAEGYAACADIBsgJSAcIBw0gAOAD4AaQIfgDSl
-AhsCGgIQAhUCFIBwgJSAloB1gHjbAFwADgBuAL0AXQBeAL4AWgC/AGAAqAIKAMECKADFAikAxwIqAGEC
-LAIKAiqAboBTgJOAcYBygAyAhoBugHLSAA4APgBpAjGANKECKoBy3xAVAFwCNAAOAjUCNgFBAjcCDAI4
-AjkCOgBeAF8COwBaAjwCPQBgAj4CPwJAAhsAiQJCAkMCRADKAHoCFAJIAMUCSQBkAkoAegBhAk0AkAIb
-Ak8AVgJQXxAfTlNEcmFnZ2luZ1NvdXJjZU1hc2tGb3JOb25Mb2NhbFlOU1R2RmxhZ3NcTlNIZWFkZXJW
-aWV3XxASTlNBbGxvd3NUeXBlU2VsZWN0XxAXTlNJbnRlcmNlbGxTcGFjaW5nV2lkdGhfEBlOU0NvbHVt
-bkF1dG9yZXNpemluZ1N0eWxlXxAYTlNJbnRlcmNlbGxTcGFjaW5nSGVpZ2h0WU5TRW5hYmxlZFtOU0dy
-aWRDb2xvcl8QD05TR3JpZFN0eWxlTWFza15OU1RhYmxlQ29sdW1uc18QHE5TRHJhZ2dpbmdTb3VyY2VN
-YXNrRm9yTG9jYWxbTlNSb3dIZWlnaHSAcICSE//////WwAAAgHSATwmAeCNACAAAAAAAACNAAAAAAAAA
-AIBzCYAMgI+AcIB7I0AxAAAAAAAAWnsxNTYsIDIwMH3XAFwADgBeAF8AWgBgAlMCFQJVAGQCVgBhAhUC
-KltOU1RhYmxlVmlld4B1gHeAdoAMgHWActsAXAAOAG4AvQBdAF4AvgBaAL8AYACoAgoAwQJdAMUCXgDH
-AkQAYQIsAgoCRIBugFOAmYCYgHSADICGgG6AdFl7MTU2LCAxN33SADcAOAJmAmekAmcBjAGNADtfEBFO
-U1RhYmxlSGVhZGVyVmlld9YAXAAOAG4AXgBaAGACCgJqAmsAZABhAgqAboB6gHmADIBuXxAUe3sxNTcs
-IDB9LCB7MTYsIDE3fX3SADcAOAJwAnGkAnEBjAGNADtdX05TQ29ybmVyVmlld9IADgA+AGkCdIA0ogJ1
-AnaAfICL2gJ4AA4CeQETAnoCewJ8An0CfgJTAHoCgAKBAoICgwFYAoQChQB6AipeTlNJc1Jlc2l6ZWFi
-bGVcTlNIZWFkZXJDZWxsWk5TRGF0YUNlbGxeTlNSZXNpemluZ01hc2taTlNNaW5XaWR0aFpOU01heFdp
-ZHRoXE5TSXNFZGl0YWJsZQmAioB9I0BRwAAAAAAAgIMjQEQAAAAAAAAjQI9AAAAAAAAJgHLXAccADgFB
-AcgByQHKAcsCiQKKAosCjAHQAIkCjhIEgf4AgIKAf4B+gGKAgFhWYXJpYWJsZdMADgFOAVYBUAFYApKA
-OUswLjMzMzMzMjk5ANUADgFUAU4BZAFlAVABSADdApYBaYA5gDqAgYA/XxAPaGVhZGVyVGV4dENvbG9y
-0gA3ADgCmgKbpQKbAeoB6wHsADtfEBFOU1RhYmxlSGVhZGVyQ2VsbNgBxwAOAUEByAHJAp0BygHLAp4B
-zQIsAqECogIqAqQCpV1OU0NvbnRyb2xWaWV3EhQh/kCAaICGgISAhYByEQgAgIhZVGV4dCBDZWxs1AAO
-AdQB1QHWAdcCqQHZAquAZCNAKgAAAAAAAIBjEQQU1QAOAVQBTgFkAWUBUAFnAN0CrwFpgDmAQYCHgD9f
-EBZjb250cm9sQmFja2dyb3VuZENvbG9y1QAOAVQBTgFkAWUBUAFIAN0CtQFpgDmAOoCJgD9fEBBjb250
-cm9sVGV4dENvbG9y0gA3ADgCuQK6ogK6ADtdTlNUYWJsZUNvbHVtbtoCeAAOAnkBEwJ6AnsCfAJ9An4C
-UwB6AoACvgK/AsABWAKEAoUAegIqCYCKgIwjQFPAAAAAAACAjgmActcBxwAOAUEByAHJAcoBywKJAooC
-iwLGAdAAiQKOgIKAf4CNgGKAgFVWYWx1ZdgBxwAOAUEByAHJAp0BygHLAp4BzQIsAqECogIqAqQCpYBo
-gIaAhICFgHKAiNUADgFUAU4BZAFlAVAC0wDdAtQBaYA5gJGAkIA/WWdyaWRDb2xvctMADgFOAVYBUAFY
-AtmAOUQwLjUA0gA3ADgC2wJTpQJTAbABjAGNADtfEBV7ezEsIDE3fSwgezE1NiwgMjAwfX3ZAFwBnwAO
-AG4AXgBaAaAAYAGhAgoCCgGkAuEAZABhAagCCgLlgG6AboBXgJWADIBWgG4jP+/gP4AAAABfEBZ7ezE1
-NywgMTd9LCB7MTUsIDIwMH192gBcAZ8ADgBuAKYAXgBaAaAAYAGhAgoCCgGkAusAkABkAGEBqAIKAu+A
-boBugFeAl4AMgFaAbiM/5vlvoAAAAF8QFXt7MSwgMjE3fSwgezE1NiwgMTV9fdIADgA+AGkC84A0oQJE
-gHRfEBN7ezEsIDB9LCB7MTU2LCAxN319XxAWe3sxOCwgMTR9LCB7MTczLCAyMzN9fV8QFHt7MSwgMX0s
-IHsyMDksIDI1N319XxAWe3s0NzQsIDB9LCB7MjExLCAyNzN9fdcBxwAOAUEByAHJAcoBywHMAc0BzgL8
-AdAAiQL+gGiAZYCegGKAn1lXb3Jrc3BhY2XTAA4BTgFWAVABWAHngDlfEBZ7ezIwLCA0NH0sIHs2ODUs
-IDI3M319XxAgaXB5dGhvbjFfY29uc29sZV93b3Jrc3BhY2Vfc3BsaXTSADcAOAMFAwakAwYBjAGNADtb
-TlNTcGxpdFZpZXfaAFwADgBuAwgDCQBeAFoDCgBgAwsATQMNAw4DDwMQAxEAYQMTAE0DFVpOU01heFZh
-bHVlWk5TTWluVmFsdWVZTlNwaUZsYWdzXE5TRHJhd01hdHJpeIALgKeApiNAWQAAAAAAACNAMAAAAAAA
-ABEFIYAMEXEKgAuApNEADgMXgKXSADcAOAMZAxqiAxoAO1pOU1BTTWF0cml4XxAVe3s2ODksIDIwfSwg
-ezE2LCAxNn190gA3ADgDHQMepAMeAYwBjQA7XxATTlNQcm9ncmVzc0luZGljYXRvclp7NzI1LCAzMzd9
-XxAVe3swLCAwfSwgezEyODAsIDc3OH19XxAQaXB5dGhvbjFfc2FuZGJveNIANwA4AyMDJKIDJAA7XxAQ
-TlNXaW5kb3dUZW1wbGF0ZdIADgA+AGkDJ4A0rxAvAygDKQMqAysDLAMtAy4DLwMwAzEDMgMzAzQDNQM2
-AzcDOAM5AzoDOwM8Az0DPgM/A0ADQQNCA0MDRANFA0YDRwNIA0kDSgNLA0wDTQNOA08DUANRA1IDUwNU
-A1UDVoCugLyAwoDIgM6A1IDZgN+A44DogOyA8YD2gPuBAQGBAQaBAQqBAQ+BARWBARqBAR+BASWBASqB
-AS+BATWBATmBAT2BAUKBAUOBAUiBAUqBAU+BAVSBAViBAVyBAV6BAWKBAWaBAWqBAW6BAXOBAXiBAX2B
-AY2BAZGBAZSBAZfTAA4DWANZA1oDWwNcWE5TU291cmNlV05TTGFiZWyAu4CvgLrYAA4DXgNfA2ADYQNi
-A2MDZANlA2YDZwNoA2kDagNrA2xXTlNUaXRsZV8QEU5TS2V5RXF1aXZNb2RNYXNrWk5TS2V5RXF1aXZd
-TlNNbmVtb25pY0xvY1lOU09uSW1hZ2VcTlNNaXhlZEltYWdlVk5TTWVudYC5gLESABAAAICyEn////+A
-s4C3gLDUAA4DXgHVA24DbwNwA3EDcltOU01lbnVJdGVtc4EBpIEByoEB2YEBzFhTaG93IEFsbNMADgAy
-A3UDdgN3A3heTlNSZXNvdXJjZU5hbWWAtoC0gLVXTlNJbWFnZV8QD05TTWVudUNoZWNrbWFya9IANwA4
-A3wDfaIDfQA7XxAQTlNDdXN0b21SZXNvdXJjZdMADgAyA3UDdgN3A4GAtoC0gLhfEBBOU01lbnVNaXhl
-ZFN0YXRl0gA3ADgDhAOFogOFADtaTlNNZW51SXRlbV8QFnVuaGlkZUFsbEFwcGxpY2F0aW9uczrSADcA
-OAOIA4mjA4kDigA7XxAVTlNOaWJDb250cm9sQ29ubmVjdG9yXk5TTmliQ29ubmVjdG9y0wAOA1gDWQNa
-A40DjoC7gL2AwdgADgNeA18DYANhA2IDYwNkA2UDkQNnA5IDaQNqA2sDlYC5gL+AwICzgLeAvtMADgNe
-A24DbwOYA5mBAaSBAauBAa1eQ2hlY2sgU3BlbGxpbmdRO15jaGVja1NwZWxsaW5nOtMADgNYA1kDWgOf
-A6CAu4DDgMfYAA4DXgNfA2ADYQNiA2MDZANlA6MDZwOkA2kDagNrA6eAuYDFgMaAs4C3gMTTAA4DXgNu
-A28DqgOrgQGkgQHbgQHdZgBQAHIAaQBuAHQgJlFwVnByaW50OtMADgNYA1kDWgOxA7KAu4DJgM3ZAA4D
-XgNfA2ADYQNiA2MDZAO0A2UDtgO3A7gDaQNqA2sDuwFYVU5TVGFngLmAyxIAEgAAgMyAs4C3gMrTAA4D
-XgNuA28DvgO/gQGkgQHAgQHCW1NtYXJ0IExpbmtzUUdfEB10b2dnbGVBdXRvbWF0aWNMaW5rRGV0ZWN0
-aW9uOtMADgNYA1kDWgPFA8aAu4DPgNPYAA4DXgNfA2ADYQNiA2MDZANlA8kDtwPKA2kDagNrA82AuYDR
-gNKAs4C3gNDTAA4DXgNuA28D0APRgQGkgQGvgQGxVFJlZG9RWlVyZWRvOtMADgNYA1kDWgPXA9iAu4DV
-gNjYAA4DXgNfA2ADYQNiA2MDZANlA9sDZwNoA2kDagNrA9+AuYDXgLKAs4C3gNbTAA4DXgNuA28D4gPj
-gQGkgQHEgQHGXlN0YXJ0IFNwZWFraW5nXnN0YXJ0U3BlYWtpbmc60wAOA1gDWQNaA+gD6YC7gNqA3tgA
-DgNeA18DYANhA2IDYwNkA2UD7ANnA+0DaQNqA2sD8IC5gNyA3YCzgLeA29MADgNeA24DbwPzA/SBAaSB
-AfGBAfNfEBRJUHl0aG9uMVNhbmRib3ggSGVscFE/WXNob3dIZWxwOtMADgNYA1kDWgP6A/uAu4DggOLY
-AA4DXgNfA2ADYQNiA2MDZANlA/4DZwNoA2kDagNrA5WAuYDhgLKAs4C3gL5fEBtDaGVjayBTcGVsbGlu
-ZyBXaGlsZSBUeXBpbmdfEB50b2dnbGVDb250aW51b3VzU3BlbGxDaGVja2luZzrTAA4DWANZA1oEBwQI
-gLuA5IDn2AAOA14DXwNgA2EDYgNjA2QDZQQLA2cEDANpA2oDawPNgLmA5YDmgLOAt4DQWlNlbGVjdCBB
-bGxRYVpzZWxlY3RBbGw60wAOA1gDWQNaBBUEFoC7gOmA69gADgNeA18DYANhA2IDYwNkA2UEGQNnA2gD
-aQNqA2sDlYC5gOqAsoCzgLeAvl8QG0NoZWNrIEdyYW1tYXIgV2l0aCBTcGVsbGluZ18QFnRvZ2dsZUdy
-YW1tYXJDaGVja2luZzrTAA4DWANZA1oEIgQjgLuA7YDw2AAOA14DXwNgA2EDYgNjA2QDZQQmA2cDaANp
-A2oDawQqgLmA74CygLOAt4Du0wAOA14DbgNvBC0ELoEBpIEB54EB6W8QEgBDAHUAcwB0AG8AbQBpAHoA
-ZQAgAFQAbwBvAGwAYgBhAHIgJl8QH3J1blRvb2xiYXJDdXN0b21pemF0aW9uUGFsZXR0ZTrTAA4DWANZ
-A1oEMwQ0gLuA8oD12AAOA14DXwNgA2EDYgNjA2QDZQQ3BDgEOQNpA2oDawQqgLmA8xIAGAAAgPSAs4C3
-gO5cU2hvdyBUb29sYmFyUXRfEBN0b2dnbGVUb29sYmFyU2hvd2460wAOA1gDWQNaBEIEQ4C7gPeA+tgA
-DgNeA18DYANhA2IDYwNkA2UERgNnBEcDaQNqA2sDp4C5gPiA+YCzgLeAxFRTYXZlUXNdc2F2ZURvY3Vt
-ZW50OtQADgRPA1gDWQRQBFEEUgRTXU5TRGVzdGluYXRpb26BAQCA/YD8gP/SAA4AMgAzADSABIAD0gAO
-ADIAMwRZgASA/l8QGklQeXRob24xU2FuZGJveEFwcERlbGVnYXRlWGRlbGVnYXRl0gA3ADgEXQReowRe
-A4oAO18QFE5TTmliT3V0bGV0Q29ubmVjdG9y0wAOA1gDWQNaBGEEYoC7gQECgQEF2QAOA14DXwNgA2ED
-YgNjA2QDtANlBGUDZwRmA2kDagNrA7sAVYC5gQEDgQEEgLOAt4DKXFNtYXJ0IFF1b3Rlc1FnXxAhdG9n
-Z2xlQXV0b21hdGljUXVvdGVTdWJzdGl0dXRpb2461AAOBE8DWANZBFAEbwRRBHGBAQCBAQeA/YEBCdIA
-DgAyADMEdIAEgQEIXxAWSVB5dGhvbkNvY29hQ29udHJvbGxlcl8QEWlweXRob25Db250cm9sbGVy0wAO
-A1gDWQNaBHkEeoC7gQELgQEO2AAOA14DXwNgA2EDYgNjA2QDZQR9A2cEfgNpA2oDawNsgLmBAQyBAQ2A
-s4C3gLBfEBRRdWl0IElQeXRob24xU2FuZGJveFFxWnRlcm1pbmF0ZTrTAA4DWANZA1oEhwSIgLuBARCB
-ARTYAA4DXgNfA2ADYQNiA2MDZANlBIsDZwSMA2kDagNrBI+AuYEBEoEBE4CzgLeBARHUAA4DXgHVA24D
-bwSSBJMElIEBpIEB64EB74EB7VhNaW5pbWl6ZVFtXxATcGVyZm9ybU1pbmlhdHVyaXplOtMADgNYA1kD
-WgSaBJuAu4EBFoEBGdgADgNeA18DYANhA2IDYwNkA2UEngNnBJ8DaQNqA2sDzYC5gQEXgQEYgLOAt4DQ
-VFVuZG9RelV1bmRvOtMADgNYA1kDWgSoBKmAu4EBG4EBHtgADgNeA18DYANhA2IDYwNkA2UErANnBK0D
-aQNqA2sDlYC5gQEcgQEdgLOAt4C+bgBTAGgAbwB3ACAAUwBwAGUAbABsAGkAbgBnICZROl8QD3Nob3dH
-dWVzc1BhbmVsOtMADgNYA1kDWgS2BLeAu4EBIIEBJNgADgNeA18DYANhA2IDYwNkA2UEugO3BLsDaQNq
-A2sEvoC5gQEigQEjgLOAt4EBIdMADgNeA24DbwTBBMKBAaSBAZ+BAaFbU2hvdyBDb2xvcnNRQ18QFW9y
-ZGVyRnJvbnRDb2xvclBhbmVsOtMADgNYA1kDWgTIBMmAu4EBJoEBKdgADgNeA18DYANhA2IDYwNkA2UE
-zAQ4BM0DaQNqA2sDbIC5gQEngQEogLOAt4CwW0hpZGUgT3RoZXJzUWhfEBZoaWRlT3RoZXJBcHBsaWNh
-dGlvbnM60wAOA1gDWQNaBNYE14C7gQErgQEu2AAOA14DXwNgA2EDYgNjA2QDZQTaA2cE2wNpA2oDawPN
-gLmBASyBAS2As4C3gNBUQ29weVFjVWNvcHk60wAOA1gDWQNaBOQE5YC7gQEwgQE02QAOA14DXwNgA2ED
-YgNjA2QDtANlBOgDZwTpA2kDagNrBOwAkIC5gQEygQEzgLOAt4EBMdMADgNeA24DbwTvBPCBAaSBAbWB
-AbdlAEYAaQBuAGQgJlFmXxAXcGVyZm9ybUZpbmRQYW5lbEFjdGlvbjrTAA4DWANZA1oE9gT3gLuBATaB
-ATjYAA4DXgNfA2ADYQNiA2MDZANlBPoDZwNoA2kDagNrA9+AuYEBN4CygLOAt4DWXVN0b3AgU3BlYWtp
-bmddc3RvcFNwZWFraW5nOtQADgRPA1gDWQNaAB8FBAUFgLuAAoEBOoEBPNcADgNeA2ADYQNiA2MDZANl
-BQgDaANpA2oDawNsgLmBATuAsoCzgLeAsF8QFUFib3V0IElQeXRob24xU2FuZGJveF8QHW9yZGVyRnJv
-bnRTdGFuZGFyZEFib3V0UGFuZWw60wAOA1gDWQNaBREFEoC7gQE+gQFB2QAOBRQDXgNfA2ADYQNiA2MD
-ZANlA2gFFwO3BRgDaQNqA2sDp1lOU1Rvb2xUaXCAuYCygQE/gQFAgLOAt4DEXVBhZ2UgU2V0dXAuLi5R
-UF5ydW5QYWdlTGF5b3V0OtQADgRPA1gDWQRQBG8AQQRTgQEAgQEHgAeA/9MADgNYA1kDWgUmBSeAu4EB
-RIEBR9gADgNeA18DYANhA2IDYwNkA2UFKgNnBSsDaQNqA2sDzYC5gQFFgQFGgLOAt4DQVVBhc3RlUXZW
-cGFzdGU61AAOBE8DWANZBFAAyABBBTaBAQCAGIAHgQFJXxAVaW5pdGlhbEZpcnN0UmVzcG9uZGVy0wAO
-A1gDWQNaBToFO4C7gQFLgQFO2AAOA14DXwNgA2EDYgNjA2QDZQU+A2cFPwNpA2oDawTsgLmBAUyBAU2A
-s4C3gQExXxARSnVtcCB0byBTZWxlY3Rpb25Ral8QHWNlbnRlclNlbGVjdGlvbkluVmlzaWJsZUFyZWE6
-0wAOA1gDWQNaBUgFSYC7gQFQgQFT2AAOA14DXwNgA2EDYgNjA2QDZQVMA2cDaANpA2oDawVQgLmBAVKA
-soCzgLeBAVHUAA4DXgHVA24DbwVTBVQFVYEBpIEBpYEBp4EBplpDbGVhciBNZW51XxAVY2xlYXJSZWNl
-bnREb2N1bWVudHM60wAOA1gDWQNaBVoFW4C7gQFVgQFX2AAOA14DXwNgA2EDYgNjA2QDZQVeA2cDaANp
-A2oDawPNgLmBAVaAsoCzgLeA0FZEZWxldGVXZGVsZXRlOtMADgNYA1kDWgVnBWiAu4EBWYEBW9cADgNe
-A2ADYQNiA2MDZANlBWsDaANpA2oDawOngLmBAVqAsoCzgLeAxF8QD1JldmVydCB0byBTYXZlZF8QFnJl
-dmVydERvY3VtZW50VG9TYXZlZDrUAA4ETwNYA1kEUADIBG8FdoEBAIAYgQEHgQFdWHRleHRWaWV30wAO
-A1gDWQNaBXoFe4C7gQFfgQFh2AAOA14DXwNgA2EDYgNjA2QDZQV+A2cDaANpA2oDawSPgLmBAWCAsoCz
-gLeBARFfEBJCcmluZyBBbGwgdG8gRnJvbnRfEA9hcnJhbmdlSW5Gcm9udDrTAA4DWANZA1oFhwWIgLuB
-AWOBAWXYAA4DXgNfA2ADYQNiA2MDZANlBYsDZwTNA2kDagNrA2yAuYEBZIEBKICzgLeAsF8QFEhpZGUg
-SVB5dGhvbjFTYW5kYm94VWhpZGU60wAOA1gDWQNaBZQFlYC7gQFngQFp2AAOA14DXwNgA2EDYgNjA2QD
-ZQWYA2cDaANpA2oDawSPgLmBAWiAsoCzgLeBARFUWm9vbVxwZXJmb3JtWm9vbTrTAA4DWANZA1oFoQWi
-gLuBAWuBAW3ZAA4DXgNfA2ADYQNiA2MDZAO0A2UFpQNnBOkDaQNqA2sDuwCQgLmBAWyBATOAs4C3gMpf
-EBBTbWFydCBDb3B5L1Bhc3RlXxAYdG9nZ2xlU21hcnRJbnNlcnREZWxldGU60wAOA1gDWQNaBa4Fr4C7
-gQFvgQFy2AAOA14DXwNgA2EDYgNjA2QDZQWyA7cFswNpA2oDawOngLmBAXCBAXGAs4C3gMRoAFMAYQB2
-AGUAIABBAHMgJlFTXxAPc2F2ZURvY3VtZW50QXM60wAOA1gDWQNaBbwFvYC7gQF0gQF32AAOA14DXwNg
-A2EDYgNjA2QDZQXAA2cFwQNpA2oDawPNgLmBAXWBAXaAs4C3gNBTQ3V0UXhUY3V0OtMADgNYA1kDWgXK
-BcuAu4EBeYEBfNgADgNeA18DYANhA2IDYwNkA2UFzgNnBc8DaQNqA2sDp4C5gQF6gQF7gLOAt4DEVUNs
-b3NlUXddcGVyZm9ybUNsb3NlOtcADgRPBdcF2ANYA1kF2QXaBFEF3AXdBd4F3wBVWU5TS2V5UGF0aFlO
-U0JpbmRpbmdfEBxOU05pYkJpbmRpbmdDb25uZWN0b3JWZXJzaW9ugQGMgP2BAYuBAYqBAX6BAYnbBeEA
-DgXiBeMF5AXlBeYF5wXoBekF6gB6BewAegXuAHoF8AXxAHoAegB6BfVfEBpOU0ZpbHRlclJlc3RyaWN0
-c0luc2VydGlvbl8QFE5TUHJlc2VydmVzU2VsZWN0aW9uXE5TSW5pdGlhbEtleVpOU0VkaXRhYmxlXk5T
-RGVjbGFyZWRLZXlzXk5TSW5pdGlhbFZhbHVlXxAiTlNDbGVhcnNGaWx0ZXJQcmVkaWNhdGVPbkluc2Vy
-dGlvbl8QGE5TU2VsZWN0c0luc2VydGVkT2JqZWN0c18QFk5TQXZvaWRzRW1wdHlTZWxlY3Rpb25fEBFO
-U1NvcnREZXNjcmlwdG9ycwmBAYgJgQGBCYEBf4EBggkJCYEBg9IADgA+AGkF+IA0owX5Be4F8YEBgIEB
-gYEBglRrZXlzU2tleVV2YWx1ZdIADgA+BgAGAYEBh6EGAoEBhNQADgYEBgUGBgYHBe4GCQB6VU5TS2V5
-Wk5TU2VsZWN0b3JbTlNBc2NlbmRpbmeBAYaBAYGBAYUJWGNvbXBhcmU60gA3ADgGDQYOogYOADtfEBBO
-U1NvcnREZXNjcmlwdG9y0gA3ADgGEAE4ogE4ADvSADcAOAYSBhOlBhMGFAYVBhYAO18QFk5TRGljdGlv
-bmFyeUNvbnRyb2xsZXJfEBFOU0FycmF5Q29udHJvbGxlcl8QEk5TT2JqZWN0Q29udHJvbGxlclxOU0Nv
-bnRyb2xsZXJfEClmaWx0ZXJQcmVkaWNhdGU6IHdvcmtzcGFjZUZpbHRlclByZWRpY2F0ZV8QD2ZpbHRl
-clByZWRpY2F0ZV8QGHdvcmtzcGFjZUZpbHRlclByZWRpY2F0ZdIANwA4BhsGHKMGHAOKADtfEBVOU05p
-YkJpbmRpbmdDb25uZWN0b3LXAA4ETwXXBdgDWANZBdkF2gRvBiAGIQXeBiMAVYEBjIEBB4EBkIEBj4EB
-foEBjl8QGWNvbnRlbnREaWN0aW9uYXJ5OiB1c2VyTlNfEBFjb250ZW50RGljdGlvbmFyeVZ1c2VyTlPX
-AA4ETwXXBdgDWANZBdkF2gXeBioF8QJ2Bi0AVYEBjIEBfoEBk4EBgoCLgQGSXxAcdmFsdWU6IGFycmFu
-Z2VkT2JqZWN0cy52YWx1ZV8QFWFycmFuZ2VkT2JqZWN0cy52YWx1ZdcADgRPBdcF2ANYA1kF2QXaBd4G
-MwXxAnUGNgBVgQGMgQF+gQGWgQGCgHyBAZVfEBp2YWx1ZTogYXJyYW5nZWRPYmplY3RzLmtleV8QE2Fy
-cmFuZ2VkT2JqZWN0cy5rZXnXAA4ETwXXBdgDWANZBdkF2gRvBjwGPQBsBj8AVYEBjIEBB4EBmoEBmYCj
-gQGYXxAZYW5pbWF0ZTogd2FpdGluZ0ZvckVuZ2luZVdhbmltYXRlXxAQd2FpdGluZ0ZvckVuZ2luZdIA
-DgA+BgAGRYEBh68QZwZGAGsE5AVaBkoCwAVQBk0CgwZPBlAE1gZSBlMGVARCAE0AfgPwA7sEBwT2A7EE
-FQP6AgoAfwNsBJoGYwOnAEECKgTIA1sEeQPfBSYFegRSBm4EbwPoAMgF3gWuBnQE7AONBUgGeAZ5BGED
-nwOVA80GfgQqBoAEUQaCBREEMwIaBoYGhwaIBokAqgaLBCIFBASoA9cAbAWHBcoCRAaUA8UGlgJ2ALEF
-OgS+BpsFvAJ1Bp4FZwagBIcFoQS2AKMGpQIQBqcGqAWUBqoGqwSPgQGcgA6BATCBAVWBAZ2AjoEBUYEB
-qICDgQGqgQGugQErgQGygQGegQG/gPeAC4AQgNuAyoDkgQE2gMmA6YDggG6AaoCwgQEWgQHYgMSAB4By
-gQEmgK+BAQuA1oEBRIEBX4D8gQHVgQEHgNqAGIEBfoEBb4EB6oEBMYC9gQFQgQHlgQHugQECgMOAvoDQ
-gQG4gO6BAeGA/YEBzoEBPoDygJSBAbyBAcmBAd6BAeaAWIEBtIDtgQE6gQEbgNWAo4EBY4EBeYB0gQHN
-gM+BAdqAi4BUgQFLgQEhgQHwgQF0gHyBAbOBAVmBAcOBARCBAWuBASCAFIEB0YCWgQHSgQGigQFngQG6
-gQHkgQER2gAOA14DXwauA2AGrwNhA2IDYwNkA2UDaANnAHoDaAB6A2kDagNrA2xdTlNJc1NlcGFyYXRv
-clxOU0lzRGlzYWJsZWSAuYCyCYCyCYCzgLeAsNoADga5A14DXwNgA2EDYgNjA2QBoANlBL4EwQNnA2gD
-aQNqA2sGUwbBWU5TU3VibWVudYC5gQEhgQGfgLKAs4C3gQGegQGg1AAOA14B1QNuA28GxAbFBsaBAaSB
-AceBAfSBAchWRm9ybWF0XnN1Ym1lbnVBY3Rpb2460gAOAD4AaQbLgDSiBqgEtoEBooEBINgADgNeA18D
-YANhA2IDYwNkA2UG0ANnBDkDaQNqA2sEvoC5gQGjgPSAs4C3gQEhWlNob3cgRm9udHPSADcAOAbXA2Si
-A2QAO1tPcGVuIFJlY2VudNIADgA+AGkG24A0oQVIgQFQXxAWX05TUmVjZW50RG9jdW1lbnRzTWVuddoA
-Dga5A14DXwNgA2EDYgNjA2QBoANlBVAFUwNnA2gDaQNqA2sDpwbmgLmBAVGBAaWAsoCzgLeAxIEBqdoA
-Dga5A14DXwNgA2EDYgNjA2QBoANlA5UDmANnA2gDaQNqA2sDzQbvgLmAvoEBq4CygLOAt4DQgQGsXxAU
-U3BlbGxpbmcgYW5kIEdyYW1tYXLSAA4APgBpBvOANKQEqAONA/oEFYEBG4C9gOCA6doADga5A14DXwNg
-A2EDYgNjA2QBoANlA80D0ANnA2gDaQNqA2sGUwcAgLmA0IEBr4CygLOAt4EBnoEBsFRFZGl00gAOAD4A
-aQcEgDStBJoDxQZSBbwE1gUmBVoEBwaeBosGTwZUBqCBARaAz4EBsoEBdIEBK4EBRIEBVYDkgQGzgQG0
-gQGqgQG/gQHD2gAOA14DXwauA2AGrwNhA2IDYwNkA2UDaANnAHoDaAB6A2kDagNrA82AuYCyCYCyCYCz
-gLeA0NoADgNeA18GrgNgBq8DYQNiA2MDZANlA2gDZwB6A2gAegNpA2oDawPNgLmAsgmAsgmAs4C3gNDa
-AA4GuQNeA18DYANhA2IDYwNkAaADZQTsBO8DZwNoA2kDagNrA80HLIC5gQExgQG1gLKAs4C3gNCBAbZU
-RmluZNIADgA+AGkHMIA0pQTkBn4GqgaGBTqBATCBAbiBAbqBAbyBAUvZAA4DXgNfA2ADYQNiA2MDZAO0
-A2UHOANnBGYDaQNqA2sE7ABVgLmBAbmBAQSAs4C3gQExWUZpbmQgTmV4dNkADgNeA18DYANhA2IDYwNk
-A7QDZQdAA7cDuANpA2oDawTsAViAuYEBu4DMgLOAt4EBMV1GaW5kIFByZXZpb3Vz2QAOA14DXwNgA2ED
-YgNjA2QDtANlB0gDZwdJA2kDagNrBOwHTYC5gQG9gQG+gLOAt4EBMRAHXxAWVXNlIFNlbGVjdGlvbiBm
-b3IgRmluZFFl2gAOBrkDXgNfA2ADYQNiA2MDZAGgA2UDuwO+A2cDaANpA2oDawPNB1iAuYDKgQHAgLKA
-s4C3gNCBAcFdU3Vic3RpdHV0aW9uc9IADgA+AGkHXIA0owWhBGEDsYEBa4EBAoDJ2gAOBrkDXgNfA2AD
-YQNiA2MDZAGgA2UD3wPiA2cDaANpA2oDawPNB2iAuYDWgQHEgLKAs4C3gNCBAcVWU3BlZWNo0gAOAD4A
-aQdsgDSiA9cE9oDVgQE2WUFNYWluTWVuddIADgA+AGkHcoA0pwaHBpYGUAZKBokGdAabgQHJgQHagQGu
-gQGdgQHmgQHqgQHw2gAOBrkDXgNfA2ADYQNiA2MDZAGgA2UDbANwA2cDaANpA2oDawZTB4KAuYCwgQHK
-gLKAs4C3gQGegQHLXxAPSVB5dGhvbjFTYW5kYm940gAOAD4AaQeGgDSrBQQGlAaCBqUGpwZGBYcEyANb
-BmMEeYEBOoEBzYEBzoEB0YEB0oEBnIEBY4EBJoCvgQHYgQEL2gAOA14DXwauA2AGrwNhA2IDYwNkA2UD
-aANnAHoDaAB6A2kDagNrA2yAuYCyCYCyCYCzgLeAsNgADgNeA18DYANhA2IDYwNkA2UHnQNnB54DaQNq
-A2sDbIC5gQHPgQHQgLOAt4CwbABQAHIAZQBmAGUAcgBlAG4AYwBlAHMgJlEs2gAOA14DXwauA2AGrwNh
-A2IDYwNkA2UDaANnAHoDaAB6A2kDagNrA2yAuYCyCYCyCYCzgLeAsNoADga5A14DXwNgA2EDYgNjA2QB
-oANlBm4HsANnA2gDaQNqA2sDbAe1gLmBAdWBAdOAsoCzgLeAsIEB1FhTZXJ2aWNlc9QADgNeAdUDbgNv
-B7AHuge7gQGkgQHTgQHXgQHW0gAOAD4AaQe+gDSgXxAPX05TU2VydmljZXNNZW512gAOA14DXwauA2AG
-rwNhA2IDYwNkA2UDaANnAHoDaAB6A2kDagNrA2yAuYCyCYCyCYCzgLeAsFxfTlNBcHBsZU1lbnXaAA4G
-uQNeA18DYANhA2IDYwNkAaADZQOnA6oDZwNoA2kDagNrBlMH0oC5gMSBAduAsoCzgLeBAZ6BAdxURmls
-ZdIADgA+AGkH1oA0qwaIBoAGTQarBcoEQgWuBWcGeAURA5+BAd6BAeGBAaiBAeSBAXmA94EBb4EBWYEB
-5YEBPoDD2AAOA14DXwNgA2EDYgNjA2QDZQfkA2cH5QNpA2oDawOngLmBAd+BAeCAs4C3gMRTTmV3UW7Y
-AA4DXgNfA2ADYQNiA2MDZANlB+0DZwfuA2kDagNrA6eAuYEB4oEB44CzgLeAxGUATwBwAGUAbiAmUW/a
-AA4DXgNfBq4DYAavA2EDYgNjA2QDZQNoA2cAegNoAHoDaQNqA2sDp4C5gLIJgLIJgLOAt4DE2gAOA14D
-XwauA2AGrwNhA2IDYwNkA2UDaANnAHoDaAB6A2kDagNrA6eAuYCyCYCyCYCzgLeAxNoADga5A14DXwNg
-A2EDYgNjA2QBoANlBCoELQNnA2gDaQNqA2sGUwgOgLmA7oEB54CygLOAt4EBnoEB6FRWaWV30gAOAD4A
-aQgSgDSiBDMEIoDygO3aAA4GuQNeA18DYANhA2IDYwNkAaADZQSPBJIDZwNoA2kDagNrBlMIHYC5gQER
-gQHrgLKAs4C3gQGegQHsVldpbmRvd9IADgA+AGkIIYA0pASHBZQGeQV6gQEQgQFngQHugQFf2gAOA14D
-XwauA2AGrwNhA2IDYwNkA2UDaANnAHoDaAB6A2kDagNrBI+AuYCyCYCyCYCzgLeBARFeX05TV2luZG93
-c01lbnXaAA4GuQNeA18DYANhA2IDYwNkAaADZQPwA/MDZwNoA2kDagNrBlMIOIC5gNuBAfGAsoCzgLeB
-AZ6BAfJUSGVscNIADgA+AGkIPIA0oQPogNpbX05TTWFpbk1lbnXSAA4APgYACEGBAYevEGcDbABNBOwD
-zQZTAnYGTQOnAnUDzQZTA80DzQAfA80DpwBBAGsGmwZUA80D3wO7A5UDlQB/AGsGhwPNA2wGlgAfAgoD
-bANsA2wGoAPNBI8AHwanAB8D8ACjAB8DpwZTBosDlQVQA6cEjwO7A6cGTwZQBOwGiQOnAB8DbAOnBCoC
-CgTsBlMDpwZTAKMDzQQqA2wDlQPfAE0DbAOnAgoDbAPNBlMCKgCjBOwGSgZTA80CKgPNA6cDzQSPA7sE
-vgB+A2wCCgNsBL4EjwTsA6cGdICwgAuBATGA0IEBnoCLgQGogMSAfIDQgQGegNCA0IACgNCAxIAHgA6B
-AfCBAb+A0IDWgMqAvoC+gGqADoEByYDQgLCBAdqAAoBugLCAsICwgQHDgNCBARGAAoEB0oACgNuAFIAC
-gMSBAZ6BAbSAvoEBUYDEgQERgMqAxIEBqoEBroEBMYEB5oDEgAKAsIDEgO6AboEBMYEBnoDEgQGegBSA
-0IDugLCAvoDWgAuAsIDEgG6AsIDQgQGegHKAFIEBMYEBnYEBnoDQgHKA0IDEgNCBARGAyoEBIYAQgLCA
-boCwgQEhgQERgQExgMSBAerSAA4APgYACKuBAYevEGgAawZGBOQFWgZKAsAFUAZNAoMGTwZQBNYGUgZT
-BlQATQRCAH4D8AO7BAcE9gOxBBUCCgP6AH8DbABBA6cEmgZjAioEyANbBHkD3wUmBXoEUgZuBG8D6ADI
-Bd4AHwWuBnQGeATsA40FSAZ5BGEDnwOVA80EKgZ+BoAEUQaCBREEMwIaBoYGhwaJBogAqgaLBCIFBABs
-BKgD1wWHBcoCRAaUA8UGlgJ2ALEEvgU6BpsFvAJ1Bp4FZwagBIcFoQS2AKMGpQIQBqcGqAWUBqoGqwSP
-gA6BAZyBATCBAVWBAZ2AjoEBUYEBqICDgQGqgQGugQErgQGygQGegQG/gAuA94AQgNuAyoDkgQE2gMmA
-6YBugOCAaoCwgAeAxIEBFoEB2IBygQEmgK+BAQuA1oEBRIEBX4D8gQHVgQEHgNqAGIEBfoACgQFvgQHq
-gQHlgQExgL2BAVCBAe6BAQKAw4C+gNCA7oEBuIEB4YD9gQHOgQE+gPKAlIEBvIEByYEB5oEB3oBYgQG0
-gO2BATqAo4EBG4DVgQFjgQF5gHSBAc2Az4EB2oCLgFSBASGBAUuBAfCBAXSAfIEBs4EBWYEBw4EBEIEB
-a4EBIIAUgQHRgJaBAdKBAaKBAWeBAbqBAeSBARHSAA4APgYACRaBAYevEGgJFwkYCRkJGgkbCRwJHQke
-CR8JIAkhCSIJIwkkCSUJJgknCSgJKQkqCSsJLAktCS4JLwkwCTEJMgkzCTQJNQk2CTcJOAk5CToJOwk8
-CT0JPgk/CUAJQQlCCUMJRAlFCUYJRwlICUkJSglLCUwJTQlOCU8JUAlRCVIEWQlUCVUJVglXCVgJWQla
-CVsJXAldCV4JXwlgCWEJYgljCWQJZQlmCWcJaAlpCWoJawlsCW0JbglvCXAJcQlyCXMJdAl1CXYJdwl4
-CXkJegl7CXwJfQl+gQH4gQH5gQH6gQH7gQH8gQH9gQH+gQH/gQIAgQIBgQICgQIDgQIEgQIFgQIGgQIH
-gQIIgQIJgQIKgQILgQIMgQINgQIOgQIPgQIQgQIRgQISgQITgQIUgQIVgQIWgQIXgQIYgQIZgQIagQIb
-gQIcgQIdgQIegQIfgQIggQIhgQIigQIjgQIkgQIlgQImgQIngQIogQIpgQIqgQIrgQIsgQItgQIugQIv
-gQIwgQIxgQIygQIzgP6BAjSBAjWBAjaBAjeBAjiBAjmBAjqBAjuBAjyBAj2BAj6BAj+BAkCBAkGBAkKB
-AkOBAkSBAkWBAkaBAkeBAkiBAkmBAkqBAkuBAkyBAk2BAk6BAk+BAlCBAlGBAlKBAlOBAlSBAlWBAlaB
-AleBAliBAlmBAlqBAluBAlyBAl2BAl5aU3BsaXQgVmlld1tTZXBhcmF0b3ItM28QEQBNAGUAbgB1ACAA
-SQB0AGUAbQAgACgARgBpAG4AZCAmAClfEBJNZW51IEl0ZW0gKERlbGV0ZSlfEBJNZW51IEl0ZW0gKEZv
-cm1hdClfEBtUZXh0IEZpZWxkIENlbGwgKFRleHQgQ2VsbClfEBJNZW51IChPcGVuIFJlY2VudClfEBdN
-ZW51IEl0ZW0gKE9wZW4gUmVjZW50KV8QHVRleHQgRmllbGQgQ2VsbCAoVGV4dCBDZWxsKS0xXxAgTWVu
-dSBJdGVtIChTcGVsbGluZyBhbmQgR3JhbW1hcilfEBBNZW51IEl0ZW0gKEVkaXQpXxAQTWVudSBJdGVt
-IChDb3B5KVlTZXBhcmF0b3JYTWFpbk1lbnVfEBlNZW51IEl0ZW0gKFN1YnN0aXR1dGlvbnMpXENvbnRl
-bnQgVmlld1EzXUJveCAoQ29uc29sZSlRMl8QFE1lbnUgKFN1YnN0aXR1dGlvbnMpXxAWTWVudSBJdGVt
-IChTZWxlY3QgQWxsKV8QGU1lbnUgSXRlbSAoU3RvcCBTcGVha2luZylfEBdNZW51IEl0ZW0gKFNtYXJ0
-IExpbmtzKV8QJ01lbnUgSXRlbSAoQ2hlY2sgR3JhbW1hciBXaXRoIFNwZWxsaW5nKV1TY3JvbGwgVmll
-dy0xXxAnTWVudSBJdGVtIChDaGVjayBTcGVsbGluZyBXaGlsZSBUeXBpbmcpXxAPQm94IChXb3Jrc3Bh
-Y2UpXxAWTWVudSAoSVB5dGhvbjFTYW5kYm94KV8QGVdpbmRvdyAoSVB5dGhvbjEgKENvY29hKSlbTWVu
-dSAoRmlsZSlfEBBNZW51IEl0ZW0gKFVuZG8pW1NlcGFyYXRvci00XxAcVGFibGUgVmlldyAoVmFyaWFi
-bGUsIFZhbHVlKV8QF01lbnUgSXRlbSAoSGlkZSBPdGhlcnMpXxAUTWVudSBJdGVtIChTaG93IEFsbClU
-MTExMV1NZW51IChTcGVlY2gpXxARTWVudSBJdGVtIChQYXN0ZSlfEB5NZW51IEl0ZW0gKEJyaW5nIEFs
-bCB0byBGcm9udClbQXBwbGljYXRpb25fEA9NZW51IChTZXJ2aWNlcylfEBdQeXRob24gQ29jb2EgQ29u
-dHJvbGxlcl8QIE1lbnUgSXRlbSAoSVB5dGhvbjFTYW5kYm94IEhlbHApWVRleHQgVmlld18QGVVzZXIg
-TmFtZXNwYWNlIENvbnRyb2xsZXJcRmlsZSdzIE93bmVyUThfEBJNZW51IEl0ZW0gKFdpbmRvdylTMi0x
-W01lbnUgKEZpbmQpXxAaTWVudSBJdGVtIChDaGVjayBTcGVsbGluZylfEBZNZW51IEl0ZW0gKENsZWFy
-IE1lbnUpW1NlcGFyYXRvci0yXxAYTWVudSBJdGVtIChTbWFydCBRdW90ZXMpUTZfEBtNZW51IChTcGVs
-bGluZyBhbmQgR3JhbW1hcilbTWVudSAoRWRpdClbTWVudSAoVmlldylfEBVNZW51IEl0ZW0gKEZpbmQg
-TmV4dClvEBEATQBlAG4AdQAgAEkAdABlAG0AIAAoAE8AcABlAG4gJgApUzEyMVE1XxAYTWVudSBJdGVt
-IChTaG93IFRvb2xiYXIpXxATVmVydGljYWwgU2Nyb2xsZXItMV8QIk1lbnUgSXRlbSAoVXNlIFNlbGVj
-dGlvbiBmb3IgRmluZClfEBtNZW51IEl0ZW0gKElQeXRob24xU2FuZGJveClfEBBNZW51IEl0ZW0gKFZp
-ZXcpUTlfEBNIb3Jpem9udGFsIFNjcm9sbGVyXxAQTWVudSBJdGVtIChGaW5kKW8QHgBNAGUAbgB1ACAA
-SQB0AGUAbQAgACgAQwB1AHMAdABvAG0AaQB6AGUAIABUAG8AbwBsAGIAYQByICYAKV8QIU1lbnUgSXRl
-bSAoQWJvdXQgSVB5dGhvbjFTYW5kYm94KVxBc3luYyBBcnJvd3NvEBoATQBlAG4AdQAgAEkAdABlAG0A
-IAAoAFMAaABvAHcAIABTAHAAZQBsAGwAaQBuAGcgJgApXxAaTWVudSBJdGVtIChTdGFydCBTcGVha2lu
-ZylfECBNZW51IEl0ZW0gKEhpZGUgSVB5dGhvbjFTYW5kYm94KVMxLTFfEBFUYWJsZSBIZWFkZXIgVmll
-d1tTZXBhcmF0b3ItNV8QEE1lbnUgSXRlbSAoUmVkbylfEBBNZW51IEl0ZW0gKEZpbGUpXxAUVGFibGUg
-Q29sdW1uIChWYWx1ZSlfEBFWZXJ0aWNhbCBTY3JvbGxlcl1NZW51IChGb3JtYXQpXxAdTWVudSBJdGVt
-IChKdW1wIHRvIFNlbGVjdGlvbilRMV8QD01lbnUgSXRlbSAoQ3V0KV8QF1RhYmxlIENvbHVtbiAoVmFy
-aWFibGUpW1NlcGFyYXRvci0xUjEwXxASTWVudSBJdGVtIChTcGVlY2gpXxAUTWVudSBJdGVtIChNaW5p
-bWl6ZSlfEBxNZW51IEl0ZW0gKFNtYXJ0IENvcHkvUGFzdGUpXxAXTWVudSBJdGVtIChTaG93IENvbG9y
-cylbU2Nyb2xsIFZpZXdbU2VwYXJhdG9yLTZfEBVIb3Jpem9udGFsIFNjcm9sbGVyLTFfEBRNZW51IEl0
-ZW0gKFNlcnZpY2VzKV8QFk1lbnUgSXRlbSAoU2hvdyBGb250cylfEBBNZW51IEl0ZW0gKFpvb20pXxAZ
-TWVudSBJdGVtIChGaW5kIFByZXZpb3VzKVE3XU1lbnUgKFdpbmRvdynSAA4APgYACeiBAYeg0gAOAD4G
-AAnrgQGHoNIADgA+BgAJ7oEBh68QlwZGAGsDUATkBVoGSgM8Az8CwAVQBk0DLQNHA1UCgwNEBk8GUAMr
-A08E1gZSAygDSAZTBlQEQgBNAH4D8AO7BAcE9gOxA0kEFQP6AgoAfwNsBJoGYwOnAEECKgTIA0EDWwNG
-BHkD3wNKBSYFegRSAzQDTgNUA1EDMgM3A00GbgRvA+gAyAXeAB8FrgZ0BOwDjQVIBngDMQM6BnkEYQOf
-AzsDlQPNAzkGfgQqAykGgARRBoIFEQQzAhoDOANFAyoGhgMwBocGiAaJAKoGiwQiAywFBASoA9cAbAWH
-A0wFygM2AkQGlAPFBpYCdgNCAzMDLgCxBToEvgabBbwCdQaeBWcGoAM1Az0EhwNLBaEEtgM+AKMDUgal
-AhADVganBqgDQANDBZQGqgMvA1MGqwSPgQGcgA6BAXOBATCBAVWBAZ2BAR+BAS+AjoEBUYEBqIDUgQFP
-gQGUgIOBAUOBAaqBAa6AyIEBboEBK4EBsoCugQFUgQGegQG/gPeAC4AQgNuAyoDkgQE2gMmBAViA6YDg
-gG6AaoCwgQEWgQHYgMSAB4BygQEmgQE5gK+BAUqBAQuA1oEBXIEBRIEBX4D8gPaBAWqBAZGBAXiA7IEB
-BoEBZoEB1YEBB4DagBiBAX6AAoEBb4EB6oEBMYC9gQFQgQHlgOiBARWBAe6BAQKAw4EBGoC+gNCBAQ+B
-AbiA7oC8gQHhgP2BAc6BAT6A8oCUgQEKgQFIgMKBAbyA44EByYEB3oEB5oBYgQG0gO2AzoEBOoEBG4DV
-gKOBAWOBAWKBAXmBAQGAdIEBzYDPgQHagIuBAT2A8YDZgFSBAUuBASGBAfCBAXSAfIEBs4EBWYEBw4D7
-gQElgQEQgQFegQFrgQEggQEqgBSBAX2BAdGAloEBl4EB0oEBooEBNYEBQoEBZ4EBuoDfgQGNgQHkgQER
-0gAOAD4GAAqIgQGHrxCXCokKigqLCowKjQqOCo8KkAqRCpIKkwqUCpUKlgqXCpgKmQqaCpsKnAqdCp4K
-nwqgCqEKogqjCqQKpQqmCqcKqAqpCqoKqwqsCq0KrgqvCrAKsQqyCrMKtAq1CrYKtwq4CrkKugq7CrwK
-vQq+Cr8KwArBCsIKwwrECsUKxgrHCsgKyQrKCssKzArNCs4KzwrQCtEK0grTCtQK1QrWCtcK2ArZCtoK
-2wrcCt0K3grfCuAK4QriCuMK5ArlCuYK5wroCukK6grrCuwK7QruCu8K8ArxCvIK8wr0CvUK9gr3CvgK
-+Qr6CvsK/Ar9Cv4K/wsACwELAgsDCwQLBQsGCwcLCAsJCwoLCwsMCw0LDgsPCxALEQsSCxMLFAsVCxYL
-FwsYCxkLGgsbCxwLHQseCx+BAmOBAmSBAmWBAmaBAmeBAmiBAmmBAmqBAmuBAmyBAm2BAm6BAm+BAnCB
-AnGBAnKBAnOBAnSBAnWBAnaBAneBAniBAnmBAnqBAnuBAnyBAn2BAn6BAn+BAoCBAoGBAoKBAoOBAoSB
-AoWBAoaBAoeBAoiBAomBAoqBAouBAoyBAo2BAo6BAo+BApCBApGBApKBApOBApSBApWBApaBApeBApiB
-ApmBApqBApuBApyBAp2BAp6BAp+BAqCBAqGBAqKBAqOBAqSBAqWBAqaBAqeBAqiBAqmBAqqBAquBAqyB
-Aq2BAq6BAq+BArCBArGBArKBArOBArSBArWBAraBAreBAriBArmBArqBAruBAryBAr2BAr6BAr+BAsCB
-AsGBAsKBAsOBAsSBAsWBAsaBAseBAsiBAsmBAsqBAsuBAsyBAs2BAs6BAs+BAtCBAtGBAtKBAtOBAtSB
-AtWBAtaBAteBAtiBAtmBAtqBAtuBAtyBAt2BAt6BAt+BAuCBAuGBAuKBAuOBAuSBAuWBAuaBAueBAuiB
-AumBAuqBAuuBAuyBAu2BAu6BAu+BAvCBAvGBAvKBAvOBAvSBAvWBAvaBAveBAviBAvkQkBEBpRDkENEQ
-yhEBKxEBaRDxEQGeEH0QfBDpEH8RAawRAZ8Q4hDYENkRAWURAWsQxRDOEQFyEOsQHREBXBBLEQF0EQGk
-EGoRAV0QxhDDEQFiEQFsEQFaENsRAZcRAZYQORDPEJUQUREBcxEBmxCREI4QlhD1EIgQ1BEBvBDLEAUT
-//////////0RAWoRAWMRAasQwREBbREBuRDwEIIRAaYQbxEBoxEBgREBvhBQEBMQ3BDJEH4QShEBWxDf
-EFwRAV8QThDmEMgQzRAlENARASgQ4RBIEQF1EIEQTREBKREBmREBcREBvRBWEN0Q6BA4EFIRAScRAaIQ
-2hEBKhDnEDoQzBDEEQG0EIYRAW8QSREBZBEBmBDsENcQUxEBnRBXEQFuEQFoEQGhENIRASwQZxDHEQGc
-ENYQcBDTEQF2EQFwEBcQJxEBXhEBWRDgEQGgEQG4EI8RAZoRAbUQgxEBWBDjEQGtEO8Q1RDeEQGoEE8Q
-GNIADgA+AGkLuYA0oNIADgA+BgALvIEBh6DSAA4APgYAC7+BAYeg0gA3ADgLwQvCogvCADteTlNJQk9i
-amVjdERhdGEACAAZACIAJwAxADoAPwBEAFIAVABmBmYGbAa3Br4GxQbTBuUHAQcPBxsHJwc1B0AHTgdq
-B3gHiwedB7cHwQfOB9AH0wfWB9kH3AfeB+EH4wfmB+kH7AfvB/EH8wf2B/kH/Af/CAgIFAgWCBgIJggv
-CDgIQwhICFcIYAhzCHwIhwiJCIwIjgi7CMgI1QjrCPkJAwkRCR4JMAlECVAJUglUCVYJWAlaCV8JYQlj
-CWUJZwlpCYQJlwmgCb0JzwnaCeMJ7wn7Cf0J/woBCgQKBgoICgoKEwoVChoKHAoeCkcKTwpeCm0Kegp8
-Cn4KgAqCCoUKhwqJCosKjAqVCpcKnAqeCqAK2QrjCu8K/QsKCxQLJgs0CzYLOAs6CzwLPQs/C0ELQwtF
-C0cLSQtLC00LVgtYC1sLXQt6C3wLfguAC4ILhAuGC48LkQuUC5YLxwvTC9wL6Av2C/gL+gv8C/4MAQwD
-DAUMBwwJDAsMDQwWDBgMHwwhDCMMJQxaDGMMbAx2DIAMigyMDI4MkAySDJQMlgyYDJsMnQyfDKEMowyl
-DK4MsAyzDLUM6gz8DQYNEw0fDSkNMg09DT8NQQ1DDUUNRw1JDUsNTg1QDVINVA1WDVgNYQ1jDYgNig2M
-DY4NkA2SDZQNlg2YDZoNnA2eDaANog2kDaYNqA2qDcYN2w34DhkONQ5bDoEOnw67DtcO9A8MDyYPWg93
-D5MPwA/JD9AP3Q/jD/oQDxAZECQQLBA+EEAQQhBLEE0QYhB1EIMQjRCPEJEQkxCVEKIQqxCtEK8QsRC6
-EMQQxhDHENAQ1xDpEPIQ+xEXESwRNRE3EToRPBFFEUwRWxFjEWwRcRF6EX8RoBGoEcIR1RHpEgASFRIo
-EioSLxIxEjMSNRI3EjkSOxJIElUSWxJdEngSgRKGEo4SmxKjEqUSpxKqErcSvxLBEsYSyBLKEs8S0RLT
-EugS9BMCEwQTBhMIEwoTERMvEzwTPhNKE18TYRNjE2UTZxN7E4QTiROWE6MTpROqE6wTrhOzE7UTtxPD
-E9AT0hPZE+IT5xP+FAsUExQcFCcULhQ1FEEUWBRwFH0UfxSCFI8UmRSmFKgUqhSyFLsUwBTJFNIU3RUC
-FQsVFBUeFSAVIhUkFSYVLxUxFTMVNRU+FVYVYxVsFXcVghWMFbkVxBXGFcgVyhXMFc4V0BXSFdsV5BX/
-FhgWIRYqFjcWThZXFl4WaRZwFo0WmRakFq4WuxbHFswWzhbQFtIW1BbWFt4W7xb2Fv0XBhcIFxEXExcW
-FyMXLBcxFzgXTRdPF1EXUxdVF2sXeBd6F4gXkReaF6wXuRfAF8kX0hfYGBEYExgVGBcYGRgaGBwYHhgg
-GCIYJBgmGC8YMRg0GDYYUxhVGFcYWRhbGF0YXxhoGGoYbRhvGK4YuxjOGNsY3RjfGOEY4xjlGOcY6Rjr
-GP4ZABkCGQQZBhkIGREZExkeGSAZIhkkGSYZKBlVGVcZWRlbGV0ZXxlhGWMZZRlnGXAZchl1GXcZzhnw
-GfoaBxocGjYaUhptGncagxqVGqQawxrPGtEa0xrcGt4a4BrhGuMa7Br1Gvca+Br6Gvwa/hsAGwkbFBsx
-Gz0bPxtBG0MbRRtHG0kbdht4G3obfBt+G4AbghuEG4YbiBuSG5sbpBu4G9Eb0xvVG9cb2RvbG/Ib+xwE
-HBIcGxwdHCIcJBwmHE8cXhxrHHYchRyQHJscqBypHKscrRy2HLgcwRzKHMsczRzqHO8c8RzzHPUc9xz5
-HQIdDx0RHR0dMh00HTYdOB06HUwdVR1gHXQdlR2jHagdqh2sHa4dsB2yHbUdtx3BHdId1B3dHd8d4h33
-Hfkd+x39Hf8eGB4tHi8eMR4zHjUeSB5RHlYeZB6NHo4ekB6SHpsenR6eHqAevR6/HsEewx7FHscezR7u
-HvAe8h70HvYe+B76Hw8fER8THxUfFx8hHy4fMB81Hz4fSR9hH4YfiB+KH4wfjh+QH5IflB+dH7Yf3x/h
-H+Mf5R/nH+kf6x/tH/YgDiAXIBkgHCAeIDQgTSBkIH0gmiCcIJ4goCCiIKQgriC7IL0g1iD5IQIhCyEX
-IUAhSyFWIWAhbSFvIXEhcyF8IYUhiCGKIY0hjyGRIZYhmCGhIaYhsSHJIdIh2yHxIfwiFCInIjAiNSJI
-IlEiUyK0IrYiuCK6IrwiviLAIsIixCLGIsgiyiLMIs4i0CLTItYi2SLcIt8i4iLlIugi6yLuIvEi9CL3
-Ivoi/SMAIwMjBiMJIwwjDyMSIxUjGCMbIx4jISMkIycjKiMtIzAjMyNAI0kjUSNTI1UjVyN4I4AjlCOf
-I60jtyPEI8sjzSPPI9Qj1iPbI90j3yPhI/Ij/iQBJAQkByQKJBMkICQvJDEkMyQ1JD0kTyRYJF0kcCR9
-JH8kgSSDJJYknySkJK8kyCTRJNgk8CT/JQwlDiUQJRIlMyU1JTclOSU7JT0lPyVMJU8lUiVVJWQlZiV1
-JYIlhCWGJYglqSWrJa0lryWxJbMltSXCJcUlyCXLJdgl2iXhJe4l8CXyJfQmGSYfJiEmIyYoJiomLCYu
-JjAmPSZAJkMmRiZSJlQmdCaBJoMmhSaHJqgmqiasJq4msCayJrQmwSbEJscmyibPJtEm1ybkJuYm6Cbq
-JwsnDScPJxEnEycVJxcnJCcnJyonLSc8J0snWCdaJ1wnXid/J4EngyeFJ4cniSeLJ5gnmyeeJ6EnuCe6
-J8Qn0SfTJ9Un1yf4J/on/Cf+KAAoAigEKCIoQyhQKFIoVChWKHcoeSh7KH0ofyiBKIMojiiQKJsoqCiq
-KKworijPKNEo0yjVKNco2SjbKPkpEikfKSEpIyklKUYpSClKKUwpTilQKVIpXyliKWUpaCmPKbEpvinA
-KcIpxCnlKecp6SnuKfAp8in0KfYqAyoFKhsqKCoqKiwqLipPKlEqUypVKlcqWSpbKmAqYipwKoEqjyqS
-KpQqliqYKqEqoyqlKq4qsCqyKs8q2CrhKugq/ysMKw4rESsUKzkrOys+K0ErQytFK0crVCtWK3oriyuO
-K5ErkyuWK58roSukK70r0SveK+Ar4yvmLAcsCSwMLA8sESwTLBUsLCwuLDksRixILEssTixvLHEsdCx3
-LHkseyx+LI8skiyVLJgsmyykLKYsvCzJLMsszizRLPIs9Cz3LPos/Cz+LQAtBS0HLQ0tGi0cLR8tIi1D
-LUUtSC1LLU0tTy1RLW4tcC2CLY8tkS2ULZctuC26Lb0twC3CLcQtxy3ULdct2i3dLekt6y4DLhAuEi4V
-LhguOS47Lj4uQS5DLkUuRy5TLlUubi57Ln0ugC6DLqQupi6pLqwuri6wLrIuty65Lr8uzC7OLtEu1C75
-Lvsu/i8BLwMvBS8ILxUvGC8bLx4vKS8rL0UvUi9UL1cvWi97L30vgC+CL4Qvhi+IL5YvpC+1L7cvuS+8
-L78v3C/eL+Ev4y/lL+cv6TABMCEwLjAwMDMwNjBbMGUwZzBpMGwwbzBxMHMwdTCDMIUwlDClMKgwqzCt
-MK8wvDC+MMEwxDDlMOcw6jDtMO8w8TDzMPkw+zECMRMxFjEYMRoxHTE1MUIxRDFHMUoxazFtMXAxczF1
-MXcxejGOMZAxsDG9Mb8xwjHFMeYx6DHrMe0x7zHxMfQyBTIIMgsyDjIRMhwyNDJBMkMyRjJJMmoybDJv
-MnEyczJ1MncyfjKGMpMylTKYMpsyuDK6Mr0yvzLBMsMyxTLXMvAzATMEMwYzCTMMMxUzIjMkMyczKjNL
-M00zUDNSM1QzVjNZM24zgDONM48zkjOVM7YzuDO7M74zwDPCM8Qz2zPhM+4z8DPzM/Y0FzQZNBw0HjQg
-NCI0JTQqNDc0RDRGNEk0TDRxNHM0djR5NHs0fTR/NJI0rTS6NLw0vzTCNOM05TToNOs07TTvNPE1AjUE
-NRY1IzUlNSg1KzVMNU41UTVUNVY1WDVaNV41YDVlNXI1dDV3NXo1mzWdNaA1ozWlNac1qTWvNbE1vzXc
-NeY18DYPNhI2FDYXNho2HTYgNk02ajaBNo42mTaoNrc23Db3NxA3JDclNyg3KTcsNy03MDczNzQ3NTc2
-Nzk3QjdEN0s3TjdRN1Q3WTddN2M3bDdvN3I3dTeGN4w3lzejN6Y3qTesN603tje/N8Q31zfgN+U37jf5
-OBI4Jjg7OEg4dDiGOKE4qjixOMk45jjpOOw47zjyOPU4+DkUOSg5LzlMOU85UjlVOVg5WjldOXw5lDmx
-ObQ5tzm6Ob05vznCOd859ToSOhU6GDobOh46IDojOj86RzpaOmM6Zjs3Ozo7PDs/O0I7RTtHO0o7TTtP
-O1I7VTtYO1s7XjthO2M7ZTtnO2k7azttO3A7cjt0O3Y7eDt6O3w7fzuCO4Q7hjuIO4s7jTuQO5I7lTuY
-O5o7nTugO6I7pDunO6o7rTuwO7I7tTu4O7s7vjvAO8I7xDvHO8k7zDvOO9E71DvWO9g72zveO+E75Dvm
-O+k76zvuO/E78zv1O/g7+zv9PAA8AjwFPAc8CTwMPA88EjwVPBc8GjwdPCA8IzwmPCk8KzwuPDA8Mzw2
-PDk8PDw/PEI8azx5PIY8iDyKPIs8jTyOPJA8kjyUPL08xzzJPMw8zzzRPNM81TzYPNs87DzvPPI89Tz4
-PP89Dj0XPRk9Hj0hPSQ9RT1HPUo9TD1OPVA9Uz1ePWc9bD14PYE9gz2GPYk9oj3LPc090D3TPdU91z3Z
-Pds93j4HPgk+Cz4OPhA+Ej4UPhY+GT4wPjk+Oz5EPkc+ST5LPk0+dj54Pno+fT5/PoE+gz6GPok+jj6X
-Ppk+tD63Prk+vD6/PsI+xT7IPso+zT7QPtM+1j7ZPwI/BD8GPwc/CT8KPww/Dj8QPzk/Oz89Pz4/QD9B
-P0M/RT9HP3A/cj91P3g/ej98P34/gD+DP4g/kT+TP54/oT+kP6c/qj+tP9I/1D/XP9o/3D/eP+E/60AQ
-QBJAFUAXQBlAG0AeQCxAUUBTQFZAWUBbQF1AYEBiQHtAfUCmQKhAqkCtQK9AsUCzQLVAuEDGQM9A0UDY
-QNtA3kDgQQlBC0ENQRBBEkEUQRZBGEEbQSJBK0EtQTJBNEE3QUFBSkFMQVtBXkFhQWRBZ0FqQW1BcEGZ
-QZtBnUGgQaJBpEGmQalBrEG+QcdByUHgQeNB5kHpQexB70HyQfVB+EH6Qf1CAEIpQitCLUIuQjBCMUIz
-QjVCN0JYQlpCXUJgQmJCZEJmQn9CgUKqQqxCrkKvQrFCskK0QrZCuELhQuNC5kLpQutC7ULvQvFC9EL9
-Qw5DEUMUQxdDGkMjQyVDJkM4Q2FDY0NlQ2ZDaENpQ2tDbUNvQ3xDpUOnQ6lDrEOuQ7BDskO1Q7hDvUPG
-Q8hD30PiQ+VD6EPrQ+5D8EPzQ/ZD+UP8Q/5EH0QhRCREJ0QpRCtELUQxRDNEVERWRFlEXEReRGBEYkRt
-RG9EmESaRJxEnUSfRKBEokSkRKZEz0TRRNNE1ETWRNdE2UTbRN1FBkUIRQpFDUUPRRFFE0UWRRlFHkUn
-RSlFLkUwRTJFW0VdRWBFY0VlRWdFaUVsRW9FdkV/RYFFikWNRZBFk0WWRb9FwUXDRcRFxkXHRclFy0XO
-Rd1GBkYIRgpGDUYPRhFGE0YWRhlGHkYnRilGLEYuRjpGQ0ZGRxdHGUcbRx5HIEcjRyVHKEcqRyxHLkcx
-RzNHNUc3RzlHO0c9Rz9HQkdFR0dHSUdLR01HT0dRR1NHVkdYR1pHXUdfR2FHY0dlR2dHakdsR29HcUd0
-R3ZHeEd6R3xHfkeBR4RHhkeJR4tHjkeQR5JHlUeYR5tHnkegR6JHpEemR6hHqketR7BHske1R7dHuUe7
-R71Hv0fBR8NHxUfHR8lHy0fNR9BH0kfUR9dH2kfdR99H4UfjR+VH50fqR+xH70fxR/NH9Uf3R/pH/UgA
-SAJIBUgOSBFI5EjmSOlI7EjvSPJI9Ej3SPpI/Ej/SQJJBUkISQtJDkkQSRJJFEkWSRhJGkkdSR9JIUkj
-SSVJJ0kpSStJLUkwSTNJNUk4STpJPUk/SUJJRUlHSUpJTUlPSVFJVElWSVlJXElfSWJJZElnSWpJbUlv
-SXFJc0l1SXhJe0l9SYBJg0mFSYdJikmNSZBJk0mVSZhJmkmdSZ9JokmkSadJqkmsSa9JsUm0SbZJuEm7
-Sb5JwUnEScZJyUnMSc9J0knVSdhJ2kndSd9J4knlSehJ60nuSfFJ+kn9StBK00rWStlK3ErfSuJK5Uro
-SutK7krxSvRK90r6Sv1LAEsDSwZLCUsMSw9LEksVSxhLG0seSyFLJEsnSypLLUswSzNLNks5SzxLP0tC
-S0VLSEtLS05LUUtUS1dLWktdS2BLY0tmS2lLbEtvS3JLdUt4S3tLfkuBS4RLhkuJS4xLj0uSS5VLmEub
-S55LoUukS6dLqkutS7BLs0u2S7lLvEu/S8JLxUvIS8tLzkvRS9RL10vaS91L4EvjS+ZL6UvsS+9L8kv1
-S/hL+0v+TAFMBEwHTBJMHkxDTFhMbUyLTKBMukzaTP1NEE0jTS1NNk1STV9NYU1vTXFNiE2hTb1N104B
-Tg9OOU5LTmROgE6MTp9Oq07KTuRO+08ATw5PIk9DT09PYU97T55PqE/ET9FP00/oT+xP+FAVUC5QOlBV
-UFdQdVCBUI1QpVDKUM5Q0FDrUQFRJlFEUVdRWVFvUYJRwVHlUfJSKVJGUmlSbVKBUo1SoFKzUspS3lLs
-UwxTDlMgUzpTRlNJU15TdVOUU65TulPGU95T9VQOVCFUPVQ/VE1UVlRZVFpUY1RmVGdUcFRzVaRVp1Wp
-VaxVr1WyVbVVuFW7Vb1VwFXDVcVVyFXLVc1V0FXTVdZV2FXbVd5V4VXjVeZV6VXsVe5V8FXyVfRV9lX4
-VftV/VYAVgJWBFYGVghWClYNVhBWElYUVhZWGVYcVh5WIVYkViZWKVYsVi9WMVYzVjZWOVY8Vj5WQVZE
-VkdWSlZMVk5WUVZTVlZWWVZcVl5WYVZkVmZWaVZsVm9WcVZ0VnZWeFZ7Vn5WgFaCVoVWh1aKVo1Wj1aR
-VpRWl1aZVpxWnlahVqRWp1apVqxWrlawVrNWtla4VrpWvVbAVsNWxlbIVstWzVbQVtJW1VbXVtlW21be
-VuFW5FbnVulW7FbvVvJW9Fb3VvpW/VcAVwNXBlcIVwtXDlcQVxNXFlcZVxxXH1ciVyVXJ1cqVy1XMFc5
-VzxYbVhwWHNYdlh5WHxYf1iCWIVYiFiLWI5YkViUWJdYmlidWKBYo1imWKlYrFivWLJYtVi4WLtYvljB
-WMRYx1jKWM1Y0FjTWNZY2VjcWN9Y4ljlWOhY61juWPFY9Fj3WPpY/VkAWQNZBlkJWQxZD1kSWRVZGFkb
-WR5ZIVkkWSdZKlktWTBZM1k2WTlZPFk/WUJZRVlIWUtZTllRWVRZV1laWV1ZYFljWWZZaVlsWW9Zcll1
-WXhZe1l+WYFZhFmHWYpZjVmQWZNZllmZWZxZn1miWaVZqFmrWa5ZsVm0WbdZulm9WcBZw1nGWclZzFnP
-WdJZ1VnYWdtZ3lnhWeRZ51nqWe1Z8FnzWfZZ+Vn8Wf9aAloFWghaC1oOWhFaFFoXWhpaHVogWiNaJlop
-WixaL1oyWjRaN1o5WjtaPVpAWkNaRVpIWkpaTFpOWlBaU1pWWlhaWlpcWl9aYlpkWmZaaVprWm1acFpy
-WnVaeFp6Wn1af1qBWoRah1qKWoxaj1qSWpRallqYWppanVqgWqJapFqmWqhaqlqsWq9asVqzWrxav1rC
-WsVax1rKWs1az1rRWtRa1lrZWtxa31rhWuNa5VrnWula61ruWvBa8lr1Wvda+Vr7Wv1a/1sBWwRbBlsI
-WwtbDVsPWxJbFVsYWxtbHVsfWyFbI1slWyhbK1stWzBbMls0WzZbOFs7Wz1bQFtCW0VbSFtKW0xbTltR
-W1NbVltZW1xbXlthW2NbZVtoW2pbbFtuW3FbdFt2W3hbe1t+W4Bbg1uGW4hbi1uOW5Bbk1uVW5hbmluc
-W55boVujW6VbrluwW7Fbulu9W75bx1vKW8tb1FvZAAAAAAAAAgIAAAAAAAALwwAAAAAAAAAAAAAAAAAA
-W+g</bytes>
-		</object>
-	</data>
-</archive>

IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPython1Sandbox.xcodeproj/project.pbxproj

@@ -1,293 +0,0 b''
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 44;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		77631A270C06C501005415CB /* Python.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 77631A260C06C501005415CB /* Python.framework */; };
-		77631A3F0C0748CF005415CB /* main.py in Resources */ = {isa = PBXBuildFile; fileRef = 77631A3E0C0748CF005415CB /* main.py */; };
-		7790198F0C07548A00326F66 /* IPython1SandboxAppDelegate.py in Resources */ = {isa = PBXBuildFile; fileRef = 7790198E0C07548A00326F66 /* IPython1SandboxAppDelegate.py */; };
-		77C8C1F90C07829500965286 /* MainMenu.xib in Resources */ = {isa = PBXBuildFile; fileRef = 77C8C1F70C07829500965286 /* MainMenu.xib */; };
-		8D11072B0486CEB800E47090 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 089C165CFE840E0CC02AAC07 /* InfoPlist.strings */; };
-		8D11072D0486CEB800E47090 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 29B97316FDCFA39411CA2CEA /* main.m */; settings = {ATTRIBUTES = (); }; };
-		8D11072F0486CEB800E47090 /* Cocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1058C7A1FEA54F0111CA2CBB /* Cocoa.framework */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		089C165DFE840E0CC02AAC07 /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = English.lproj/InfoPlist.strings; sourceTree = "<group>"; };
-		1058C7A1FEA54F0111CA2CBB /* Cocoa.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Cocoa.framework; path = /System/Library/Frameworks/Cocoa.framework; sourceTree = "<absolute>"; };
-		13E42FB307B3F0F600E4EEF1 /* CoreData.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreData.framework; path = /System/Library/Frameworks/CoreData.framework; sourceTree = "<absolute>"; };
-		29B97316FDCFA39411CA2CEA /* main.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = "<group>"; };
-		29B97324FDCFA39411CA2CEA /* AppKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AppKit.framework; path = /System/Library/Frameworks/AppKit.framework; sourceTree = "<absolute>"; };
-		29B97325FDCFA39411CA2CEA /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = /System/Library/Frameworks/Foundation.framework; sourceTree = "<absolute>"; };
-		32CA4F630368D1EE00C91783 /* IPython1Sandbox_Prefix.pch */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IPython1Sandbox_Prefix.pch; sourceTree = "<group>"; };
-		4CA32F870D8879B100311764 /* IPythonCocoaController Tests-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "IPythonCocoaController Tests-Info.plist"; sourceTree = "<group>"; };
-		77631A260C06C501005415CB /* Python.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Python.framework; path = /System/Library/Frameworks/Python.framework; sourceTree = "<absolute>"; };
-		77631A3E0C0748CF005415CB /* main.py */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.python; path = main.py; sourceTree = "<group>"; };
-		7790198E0C07548A00326F66 /* IPython1SandboxAppDelegate.py */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.python; path = IPython1SandboxAppDelegate.py; sourceTree = "<group>"; };
-		77C8C1F80C07829500965286 /* English */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = English; path = English.lproj/MainMenu.xib; sourceTree = "<group>"; };
-		8D1107310486CEB800E47090 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		8D1107320486CEB800E47090 /* IPython1Sandbox.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = IPython1Sandbox.app; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		8D11072E0486CEB800E47090 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				8D11072F0486CEB800E47090 /* Cocoa.framework in Frameworks */,
-				77631A270C06C501005415CB /* Python.framework in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		080E96DDFE201D6D7F000001 /* Classes */ = {
-			isa = PBXGroup;
-			children = (
-				7790198E0C07548A00326F66 /* IPython1SandboxAppDelegate.py */,
-			);
-			name = Classes;
-			sourceTree = "<group>";
-		};
-		1058C7A0FEA54F0111CA2CBB /* Linked Frameworks */ = {
-			isa = PBXGroup;
-			children = (
-				77631A260C06C501005415CB /* Python.framework */,
-				1058C7A1FEA54F0111CA2CBB /* Cocoa.framework */,
-			);
-			name = "Linked Frameworks";
-			sourceTree = "<group>";
-		};
-		1058C7A2FEA54F0111CA2CBB /* Other Frameworks */ = {
-			isa = PBXGroup;
-			children = (
-				29B97324FDCFA39411CA2CEA /* AppKit.framework */,
-				13E42FB307B3F0F600E4EEF1 /* CoreData.framework */,
-				29B97325FDCFA39411CA2CEA /* Foundation.framework */,
-			);
-			name = "Other Frameworks";
-			sourceTree = "<group>";
-		};
-		19C28FACFE9D520D11CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				8D1107320486CEB800E47090 /* IPython1Sandbox.app */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		29B97314FDCFA39411CA2CEA /* IPython1Sandbox */ = {
-			isa = PBXGroup;
-			children = (
-				080E96DDFE201D6D7F000001 /* Classes */,
-				29B97315FDCFA39411CA2CEA /* Other Sources */,
-				29B97317FDCFA39411CA2CEA /* Resources */,
-				29B97323FDCFA39411CA2CEA /* Frameworks */,
-				19C28FACFE9D520D11CA2CBB /* Products */,
-				4CA32F870D8879B100311764 /* IPythonCocoaController Tests-Info.plist */,
-			);
-			name = IPython1Sandbox;
-			sourceTree = "<group>";
-		};
-		29B97315FDCFA39411CA2CEA /* Other Sources */ = {
-			isa = PBXGroup;
-			children = (
-				32CA4F630368D1EE00C91783 /* IPython1Sandbox_Prefix.pch */,
-				29B97316FDCFA39411CA2CEA /* main.m */,
-				77631A3E0C0748CF005415CB /* main.py */,
-			);
-			name = "Other Sources";
-			sourceTree = "<group>";
-		};
-		29B97317FDCFA39411CA2CEA /* Resources */ = {
-			isa = PBXGroup;
-			children = (
-				77C8C1F70C07829500965286 /* MainMenu.xib */,
-				8D1107310486CEB800E47090 /* Info.plist */,
-				089C165CFE840E0CC02AAC07 /* InfoPlist.strings */,
-			);
-			name = Resources;
-			sourceTree = "<group>";
-		};
-		29B97323FDCFA39411CA2CEA /* Frameworks */ = {
-			isa = PBXGroup;
-			children = (
-				1058C7A0FEA54F0111CA2CBB /* Linked Frameworks */,
-				1058C7A2FEA54F0111CA2CBB /* Other Frameworks */,
-			);
-			name = Frameworks;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXNativeTarget section */
-		8D1107260486CEB800E47090 /* IPython1Sandbox */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = C01FCF4A08A954540054247B /* Build configuration list for PBXNativeTarget "IPython1Sandbox" */;
-			buildPhases = (
-				8D1107290486CEB800E47090 /* Resources */,
-				8D11072C0486CEB800E47090 /* Sources */,
-				8D11072E0486CEB800E47090 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = IPython1Sandbox;
-			productInstallPath = "$(HOME)/Applications";
-			productName = IPython1Sandbox;
-			productReference = 8D1107320486CEB800E47090 /* IPython1Sandbox.app */;
-			productType = "com.apple.product-type.application";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		29B97313FDCFA39411CA2CEA /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = C01FCF4E08A954540054247B /* Build configuration list for PBXProject "IPython1Sandbox" */;
-			compatibilityVersion = "Xcode 3.0";
-			hasScannedForEncodings = 1;
-			mainGroup = 29B97314FDCFA39411CA2CEA /* IPython1Sandbox */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				8D1107260486CEB800E47090 /* IPython1Sandbox */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXResourcesBuildPhase section */
-		8D1107290486CEB800E47090 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				8D11072B0486CEB800E47090 /* InfoPlist.strings in Resources */,
-				77631A3F0C0748CF005415CB /* main.py in Resources */,
-				7790198F0C07548A00326F66 /* IPython1SandboxAppDelegate.py in Resources */,
-				77C8C1F90C07829500965286 /* MainMenu.xib in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		8D11072C0486CEB800E47090 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				8D11072D0486CEB800E47090 /* main.m in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin PBXVariantGroup section */
-		089C165CFE840E0CC02AAC07 /* InfoPlist.strings */ = {
-			isa = PBXVariantGroup;
-			children = (
-				089C165DFE840E0CC02AAC07 /* English */,
-			);
-			name = InfoPlist.strings;
-			sourceTree = "<group>";
-		};
-		77C8C1F70C07829500965286 /* MainMenu.xib */ = {
-			isa = PBXVariantGroup;
-			children = (
-				77C8C1F80C07829500965286 /* English */,
-			);
-			name = MainMenu.xib;
-			sourceTree = "<group>";
-		};
-/* End PBXVariantGroup section */
-
-/* Begin XCBuildConfiguration section */
-		C01FCF4B08A954540054247B /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 1;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PRECOMPILE_PREFIX_HEADER = YES;
-				GCC_PREFIX_HEADER = IPython1Sandbox_Prefix.pch;
-				INFOPLIST_FILE = Info.plist;
-				INSTALL_PATH = "$(HOME)/Applications";
-				PRODUCT_NAME = IPython1Sandbox;
-				VERSIONING_SYSTEM = "apple-generic";
-				WRAPPER_EXTENSION = app;
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		C01FCF4C08A954540054247B /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				CURRENT_PROJECT_VERSION = 1;
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				GCC_MODEL_TUNING = G5;
-				GCC_PRECOMPILE_PREFIX_HEADER = YES;
-				GCC_PREFIX_HEADER = IPython1Sandbox_Prefix.pch;
-				INFOPLIST_FILE = Info.plist;
-				INSTALL_PATH = "$(HOME)/Applications";
-				PRODUCT_NAME = IPython1Sandbox;
-				VERSIONING_SYSTEM = "apple-generic";
-				WRAPPER_EXTENSION = app;
-			};
-			name = Release;
-		};
-		C01FCF4F08A954540054247B /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				PREBINDING = NO;
-				SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk";
-			};
-			name = Debug;
-		};
-		C01FCF5008A954540054247B /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = (
-					ppc,
-					i386,
-				);
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				PREBINDING = NO;
-				SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		C01FCF4A08A954540054247B /* Build configuration list for PBXNativeTarget "IPython1Sandbox" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				C01FCF4B08A954540054247B /* Debug */,
-				C01FCF4C08A954540054247B /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		C01FCF4E08A954540054247B /* Build configuration list for PBXProject "IPython1Sandbox" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				C01FCF4F08A954540054247B /* Debug */,
-				C01FCF5008A954540054247B /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 29B97313FDCFA39411CA2CEA /* Project object */;
-}

IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPython1SandboxAppDelegate.py

@@ -1,39 +0,0 b''
-#
-#  IPython1SandboxAppDelegate.py
-#  IPython1Sandbox
-#
-#  Created by Barry Wark on 3/4/08.
-#  Copyright __MyCompanyName__ 2008. All rights reserved.
-#
-
-from Foundation import NSObject, NSPredicate
-import objc
-import threading
-
-from PyObjCTools import AppHelper
-
-from twisted.internet import reactor
-
-class IPython1SandboxAppDelegate(NSObject):
-    ipythonController = objc.IBOutlet()
-    
-    def applicationShouldTerminate_(self, sender):
-        if reactor.running:
-            reactor.addSystemEventTrigger(
-                'after', 'shutdown', AppHelper.stopEventLoop)
-            reactor.stop()
-            return False
-        return True
-    
-    
-    def applicationDidFinishLaunching_(self, sender):
-        reactor.interleave(AppHelper.callAfter)
-        assert(reactor.running)
-    
-    
-    def workspaceFilterPredicate(self):
-        return NSPredicate.predicateWithFormat_("NOT (self.value BEGINSWITH '<')")
-
-
-    
-

IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPython1Sandbox_Prefix.pch

@@ -1,7 +0,0 b''
-//
-// Prefix header for all source files of the 'IPython1Sandbox' target in the 'IPython1Sandbox' project
-//
-
-#ifdef __OBJC__
-    #import <Cocoa/Cocoa.h>
-#endif

IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPythonCocoaController Tests-Info.plist

@@ -1,20 +0,0 b''
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>English</string>
-	<key>CFBundleExecutable</key>
-	<string>${EXECUTABLE_NAME}</string>
-	<key>CFBundleIdentifier</key>
-	<string>com.yourcompany.IPythonCocoaController Tests</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundlePackageType</key>
-	<string>BNDL</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1.0</string>
-</dict>
-</plist>

IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/Info.plist

@@ -1,30 +0,0 b''
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>English</string>
-	<key>CFBundleExecutable</key>
-	<string>${EXECUTABLE_NAME}</string>
-	<key>CFBundleIconFile</key>
-	<string></string>
-	<key>CFBundleIdentifier</key>
-	<string>com.yourcompany.IPython1Sandbox</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>${PRODUCT_NAME}</string>
-	<key>CFBundlePackageType</key>
-	<string>APPL</string>
-	<key>CFBundleShortVersionString</key>
-	<string>0.1</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1.0</string>
-	<key>NSMainNibFile</key>
-	<string>MainMenu</string>
-	<key>NSPrincipalClass</key>
-	<string>NSApplication</string>
-</dict>
-</plist>

IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/main.m

@@ -1,49 +0,0 b''
-//
-//  main.m
-//  IPython1Sandbox
-//
-//  Created by Barry Wark on 3/4/08.
-//  Copyright __MyCompanyName__ 2008. All rights reserved.
-//
-
-#import <Python/Python.h>
-#import <Cocoa/Cocoa.h>
-
-int main(int argc, char *argv[])
-{
-    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-    
-    NSBundle *mainBundle = [NSBundle mainBundle];
-    NSString *resourcePath = [mainBundle resourcePath];
-    NSArray *pythonPathArray = [NSArray arrayWithObjects: resourcePath, [resourcePath stringByAppendingPathComponent:@"PyObjC"], nil];
-    
-    setenv("PYTHONPATH", [[pythonPathArray componentsJoinedByString:@":"] UTF8String], 1);
-    
-    NSArray *possibleMainExtensions = [NSArray arrayWithObjects: @"py", @"pyc", @"pyo", nil];
-    NSString *mainFilePath = nil;
-    
-    for (NSString *possibleMainExtension in possibleMainExtensions) {
-        mainFilePath = [mainBundle pathForResource: @"main" ofType: possibleMainExtension];
-        if ( mainFilePath != nil ) break;
-    }
-    
-	if ( !mainFilePath ) {
-        [NSException raise: NSInternalInconsistencyException format: @"%s:%d main() Failed to find the Main.{py,pyc,pyo} file in the application wrapper's Resources directory.", __FILE__, __LINE__];
-    }
-    
-    Py_SetProgramName("/usr/bin/python");
-    Py_Initialize();
-    PySys_SetArgv(argc, (char **)argv);
-    
-    const char *mainFilePathPtr = [mainFilePath UTF8String];
-    FILE *mainFile = fopen(mainFilePathPtr, "r");
-    int result = PyRun_SimpleFile(mainFile, (char *)[[mainFilePath lastPathComponent] UTF8String]);
-    
-    if ( result != 0 )
-        [NSException raise: NSInternalInconsistencyException
-                    format: @"%s:%d main() PyRun_SimpleFile failed with file '%@'.  See console for errors.", __FILE__, __LINE__, mainFilePath];
-    
-    [pool drain];
-    
-    return result;
-}

IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/main.py

@@ -1,24 +0,0 b''
-#
-#  main.py
-#  IPython1Sandbox
-#
-#  Created by Barry Wark on 3/4/08.
-#  Copyright __MyCompanyName__ 2008. All rights reserved.
-#
-
-#import modules required by application
-import objc
-import Foundation
-import AppKit
-
-from PyObjCTools import AppHelper
-
-from twisted.internet import _threadedselect
-reactor = _threadedselect.install()
-
-# import modules containing classes required to start application and load MainMenu.nib
-import IPython1SandboxAppDelegate
-import IPython.frontend.cocoa.cocoa_frontend
-
-# pass control to AppKit
-AppHelper.runEventLoop()

IPython/deathrow/oldfrontend/cocoa/plugin/CocoaFrontendPlugin.xcodeproj/project.pbxproj

@@ -1,256 +0,0 b''
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXContainerItemProxy section */
-		4C5B7ADB0E1A0BCD006CB905 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 4C96F4FE0E199AB500B03430 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 4C96F50C0E199AF100B03430;
-			remoteInfo = "Cocoa Frontend Plugin";
-		};
-/* End PBXContainerItemProxy section */
-
-/* Begin PBXFileReference section */
-		4C5B7A8D0E1A0B4C006CB905 /* Plugin-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "Plugin-Info.plist"; sourceTree = "<group>"; };
-		4C5B7AD30E1A0BC8006CB905 /* Placeholder (Do Not Use).bundle */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "Placeholder (Do Not Use).bundle"; sourceTree = BUILT_PRODUCTS_DIR; };
-		4C5B7AD40E1A0BC8006CB905 /* Placeholder (Do Not Use)-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "Placeholder (Do Not Use)-Info.plist"; sourceTree = "<group>"; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		4C5B7AD10E1A0BC8006CB905 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		4C5B7A8C0E1A0B4C006CB905 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				4C5B7AD30E1A0BC8006CB905 /* Placeholder (Do Not Use).bundle */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		4C96F4FC0E199AB500B03430 = {
-			isa = PBXGroup;
-			children = (
-				4C5B7A8C0E1A0B4C006CB905 /* Products */,
-				4C5B7A8D0E1A0B4C006CB905 /* Plugin-Info.plist */,
-				4C5B7AD40E1A0BC8006CB905 /* Placeholder (Do Not Use)-Info.plist */,
-			);
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXLegacyTarget section */
-		4C96F50C0E199AF100B03430 /* Cocoa Frontend Plugin */ = {
-			isa = PBXLegacyTarget;
-			buildArgumentsString = "$(ACTION)";
-			buildConfigurationList = 4C96F5110E199B3300B03430 /* Build configuration list for PBXLegacyTarget "Cocoa Frontend Plugin" */;
-			buildPhases = (
-			);
-			buildToolPath = /usr/bin/make;
-			buildWorkingDirectory = "";
-			dependencies = (
-			);
-			name = "Cocoa Frontend Plugin";
-			passBuildSettingsInEnvironment = 1;
-			productName = "Cocoa Frontend Plugin";
-		};
-/* End PBXLegacyTarget section */
-
-/* Begin PBXNativeTarget section */
-		4C5B7AD20E1A0BC8006CB905 /* Placeholder (Do Not Use) */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 4C5B7ADA0E1A0BC9006CB905 /* Build configuration list for PBXNativeTarget "Placeholder (Do Not Use)" */;
-			buildPhases = (
-				4C5B7ACF0E1A0BC8006CB905 /* Resources */,
-				4C5B7AD00E1A0BC8006CB905 /* Sources */,
-				4C5B7AD10E1A0BC8006CB905 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				4C5B7ADC0E1A0BCD006CB905 /* PBXTargetDependency */,
-			);
-			name = "Placeholder (Do Not Use)";
-			productName = "Placeholder (Do Not Use)";
-			productReference = 4C5B7AD30E1A0BC8006CB905 /* Placeholder (Do Not Use).bundle */;
-			productType = "com.apple.product-type.bundle";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		4C96F4FE0E199AB500B03430 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 4C96F5010E199AB500B03430 /* Build configuration list for PBXProject "CocoaFrontendPlugin" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 0;
-			mainGroup = 4C96F4FC0E199AB500B03430;
-			productRefGroup = 4C5B7A8C0E1A0B4C006CB905 /* Products */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				4C96F50C0E199AF100B03430 /* Cocoa Frontend Plugin */,
-				4C5B7AD20E1A0BC8006CB905 /* Placeholder (Do Not Use) */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXResourcesBuildPhase section */
-		4C5B7ACF0E1A0BC8006CB905 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		4C5B7AD00E1A0BC8006CB905 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin PBXTargetDependency section */
-		4C5B7ADC0E1A0BCD006CB905 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 4C96F50C0E199AF100B03430 /* Cocoa Frontend Plugin */;
-			targetProxy = 4C5B7ADB0E1A0BCD006CB905 /* PBXContainerItemProxy */;
-		};
-/* End PBXTargetDependency section */
-
-/* Begin XCBuildConfiguration section */
-		4C5B7AD50E1A0BC9006CB905 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PRECOMPILE_PREFIX_HEADER = YES;
-				GCC_PREFIX_HEADER = "$(SYSTEM_LIBRARY_DIR)/Frameworks/AppKit.framework/Headers/AppKit.h";
-				INFOPLIST_FILE = "Placeholder (Do Not Use)-Info.plist";
-				INSTALL_PATH = "$(HOME)/Library/Bundles";
-				OTHER_LDFLAGS = (
-					"-framework",
-					Foundation,
-					"-framework",
-					AppKit,
-				);
-				PREBINDING = NO;
-				PRODUCT_NAME = "Placeholder (Do Not Use)";
-				WRAPPER_EXTENSION = bundle;
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		4C5B7AD60E1A0BC9006CB905 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = YES;
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				GCC_ENABLE_FIX_AND_CONTINUE = NO;
-				GCC_MODEL_TUNING = G5;
-				GCC_PRECOMPILE_PREFIX_HEADER = YES;
-				GCC_PREFIX_HEADER = "$(SYSTEM_LIBRARY_DIR)/Frameworks/AppKit.framework/Headers/AppKit.h";
-				INFOPLIST_FILE = "Placeholder (Do Not Use)-Info.plist";
-				INSTALL_PATH = "$(HOME)/Library/Bundles";
-				OTHER_LDFLAGS = (
-					"-framework",
-					Foundation,
-					"-framework",
-					AppKit,
-				);
-				PREBINDING = NO;
-				PRODUCT_NAME = "Placeholder (Do Not Use)";
-				WRAPPER_EXTENSION = bundle;
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-		4C96F4FF0E199AB500B03430 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-			};
-			name = Debug;
-		};
-		4C96F5000E199AB500B03430 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = YES;
-			};
-			name = Release;
-		};
-		4C96F50D0E199AF100B03430 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				PRODUCT_NAME = "Cocoa Frontend Plugin";
-			};
-			name = Debug;
-		};
-		4C96F50E0E199AF100B03430 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = YES;
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				GCC_ENABLE_FIX_AND_CONTINUE = NO;
-				PRODUCT_NAME = "Cocoa Frontend Plugin";
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		4C5B7ADA0E1A0BC9006CB905 /* Build configuration list for PBXNativeTarget "Placeholder (Do Not Use)" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				4C5B7AD50E1A0BC9006CB905 /* Debug */,
-				4C5B7AD60E1A0BC9006CB905 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		4C96F5010E199AB500B03430 /* Build configuration list for PBXProject "CocoaFrontendPlugin" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				4C96F4FF0E199AB500B03430 /* Debug */,
-				4C96F5000E199AB500B03430 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		4C96F5110E199B3300B03430 /* Build configuration list for PBXLegacyTarget "Cocoa Frontend Plugin" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				4C96F50D0E199AF100B03430 /* Debug */,
-				4C96F50E0E199AF100B03430 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 4C96F4FE0E199AB500B03430 /* Project object */;
-}

IPython/deathrow/oldfrontend/cocoa/plugin/IPythonCocoaFrontendLoader.py

@@ -1,25 +0,0 b''
-# encoding: utf-8
-"""
-Provides a namespace for loading the Cocoa frontend via a Cocoa plugin.
-
-Author: Barry Wark
-"""
-__docformat__ = "restructuredtext en"
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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.
-#-----------------------------------------------------------------------------
-
-from PyObjCTools import AppHelper
-from twisted.internet import _threadedselect
-
-#make sure _threadedselect is installed first
-reactor = _threadedselect.install()
-
-# load the Cocoa frontend controller
-from IPython.frontend.cocoa.cocoa_frontend import IPythonCocoaController
-reactor.interleave(AppHelper.callAfter)
-assert(reactor.running)

IPython/deathrow/oldfrontend/cocoa/plugin/Makefile

@@ -1,6 +0,0 b''
-include ./plugins.mk
-
-all : dist/IPythonCocoaController.plugin
-
-dist/IPythonCocoaController.plugin : ./IPythonCocoaFrontendLoader.py\
- ./setup.py
  No newline at end of file

IPython/deathrow/oldfrontend/cocoa/plugin/Placeholder (Do Not Use)-Info.plist

@@ -1,20 +0,0 b''
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>English</string>
-	<key>CFBundleExecutable</key>
-	<string>${EXECUTABLE_NAME}</string>
-	<key>CFBundleIdentifier</key>
-	<string>com.yourcompany.Placeholder (Do Not Use)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundlePackageType</key>
-	<string>BNDL</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1.0</string>
-</dict>
-</plist>

IPython/deathrow/oldfrontend/cocoa/plugin/plugins.mk

@@ -1,21 +0,0 b''
-%.plugin::
-	rm -rf dist/$(notdir $@)
-	rm -rf build dist && \
-	python setup.py py2app -s
-
-%.py:
-	@echo "test -f $@"
-	@test -f %@
-
-%.nib:
-	@echo "test -f $@"
-	@test -f %@
-
-.DEFAULT_GOAL := all
-
-.PHONY : all clean
-
-clean :
-	rm -rf build dist
-
-

IPython/deathrow/oldfrontend/cocoa/plugin/setup.py

@@ -1,35 +0,0 b''
-# encoding: utf-8
-"""
-setup.py
-
-Setuptools installer script for generating a Cocoa plugin for the
-IPython cocoa frontend
-
-Author: Barry Wark
-"""
-__docformat__ = "restructuredtext en"
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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.
-#-----------------------------------------------------------------------------
-
-from setuptools import setup
-
-infoPlist = dict(
-        CFBundleDevelopmentRegion='English',
-        CFBundleIdentifier='org.scipy.ipython.cocoa_frontend',
-        NSPrincipalClass='IPythonCocoaController',
-)
-
-setup(
-        plugin=['IPythonCocoaFrontendLoader.py'],
-    setup_requires=['py2app'],
-        options=dict(py2app=dict(
-                plist=infoPlist,
-                site_packages=True,
-                excludes=['IPython','twisted','PyObjCTools']
-        )),
-)
  No newline at end of file

IPython/deathrow/oldfrontend/cocoa/tests/test_cocoa_frontend.py

@@ -1,100 +0,0 b''
-# encoding: utf-8
-"""This file contains unittests for the
-IPython.frontend.cocoa.cocoa_frontend module.
-"""
-__docformat__ = "restructuredtext en"
-
-#---------------------------------------------------------------------------
-#       Copyright (C) 2005-2011  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
-#---------------------------------------------------------------------------
-
-# Tell nose to skip this module
-__test__ = {}
-
-from twisted.trial import unittest
-from twisted.internet.defer import succeed
-
-from IPython.kernel.core.interpreter import Interpreter
-import IPython.kernel.engineservice as es
-
-try:
-    from IPython.frontend.cocoa.cocoa_frontend import IPythonCocoaController
-    from Foundation import NSMakeRect
-    from AppKit import NSTextView, NSScrollView
-except ImportError:
-    # This tells twisted.trial to skip this module if PyObjC is not found
-    skip = True
-
-#---------------------------------------------------------------------------
-# Tests
-#---------------------------------------------------------------------------
-class TestIPythonCocoaControler(unittest.TestCase):
-    """Tests for IPythonCocoaController"""
-
-    def setUp(self):
-        self.controller = IPythonCocoaController.alloc().init()
-        self.engine = es.EngineService()
-        self.engine.startService()
-
-    def tearDown(self):
-        self.controller = None
-        self.engine.stopService()
-
-    def testControllerExecutesCode(self):
-        code ="""5+5"""
-        expected = Interpreter().execute(code)
-        del expected['number']
-        def removeNumberAndID(result):
-            del result['number']
-            del result['id']
-            return result
-        d = self.controller.execute(code)
-        d.addCallback(removeNumberAndID)
-        d.addCallback(lambda r: self.assertEquals(r, expected))
-
-    def testControllerMirrorsUserNSWithValuesAsStrings(self):
-        code = """userns1=1;userns2=2"""
-        def testControllerUserNS(result):
-            self.assertEquals(self.controller.userNS['userns1'], 1)
-            self.assertEquals(self.controller.userNS['userns2'], 2)
-        self.controller.execute(code).addCallback(testControllerUserNS)
-
-    def testControllerInstantiatesIEngine(self):
-        self.assert_(es.IEngineBase.providedBy(self.controller.engine))
-
-    def testControllerCompletesToken(self):
-        code = """longNameVariable=10"""
-        def testCompletes(result):
-            self.assert_("longNameVariable" in result)
-
-        def testCompleteToken(result):
-            self.controller.complete("longNa").addCallback(testCompletes)
-
-        self.controller.execute(code).addCallback(testCompletes)
-
-
-    def testCurrentIndent(self):
-        """test that current_indent_string returns current indent or None.
-        Uses _indent_for_block for direct unit testing.
-        """
-
-        self.controller.tabUsesSpaces = True
-        self.assert_(self.controller._indent_for_block("""a=3""") == None)
-        self.assert_(self.controller._indent_for_block("") == None)
-        block = """def test():\n    a=3"""
-        self.assert_(self.controller._indent_for_block(block) == \
-                    ' ' * self.controller.tabSpaces)
-
-        block = """if(True):\n%sif(False):\n%spass""" % \
-                    (' '*self.controller.tabSpaces,
-                     2*' '*self.controller.tabSpaces)
-        self.assert_(self.controller._indent_for_block(block) == \
-                    2*(' '*self.controller.tabSpaces))
-

IPython/deathrow/oldfrontend/frontendbase.py

@@ -1,343 +0,0 b''
-# encoding: utf-8
-# -*- test-case-name: IPython.frontend.tests.test_frontendbase -*-
-"""
-frontendbase provides an interface and base class for GUI frontends for
-IPython.kernel/IPython.kernel.core.
-
-Frontend implementations will likely want to subclass FrontEndBase.
-
-Author: Barry Wark
-"""
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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 string
-import codeop
-import uuid
-
-
-from IPython.frontend.zopeinterface import (
-    Interface,
-    Attribute,
-)
-from IPython.kernel.core.history import FrontEndHistory
-from IPython.kernel.core.util import Bunch
-
-##############################################################################
-# TEMPORARY!!! fake configuration, while we decide whether to use tconfig or
-# not
-
-rc = Bunch()
-rc.prompt_in1 = r'In [$number]:  '
-rc.prompt_in2 = r'...'
-rc.prompt_out = r'Out [$number]:  '
-
-##############################################################################
-# Interface definitions
-##############################################################################
-
-class IFrontEndFactory(Interface):
-    """Factory interface for frontends."""
-
-    def __call__(engine=None, history=None):
-        """
-        Parameters:
-        interpreter : IPython.kernel.engineservice.IEngineCore
-        """
-
-        pass
-
-
-class IFrontEnd(Interface):
-    """Interface for frontends. All methods return t.i.d.Deferred"""
-
-    Attribute("input_prompt_template", "string.Template instance\
-                substituteable with execute result.")
-    Attribute("output_prompt_template", "string.Template instance\
-                substituteable with execute result.")
-    Attribute("continuation_prompt_template", "string.Template instance\
-                substituteable with execute result.")
-
-    def update_cell_prompt(result, blockID=None):
-        """Subclass may override to update the input prompt for a block.
-
-        In asynchronous frontends, this method will be called as a
-        twisted.internet.defer.Deferred's callback/errback.
-        Implementations should thus return result when finished.
-
-        Result is a result dict in case of success, and a
-        twisted.python.util.failure.Failure in case of an error
-        """
-
-        pass
-
-    def render_result(result):
-        """Render the result of an execute call. Implementors may choose the
-         method of rendering.
-        For example, a notebook-style frontend might render a Chaco plot
-        inline.
-
-        Parameters:
-            result : dict (result of IEngineBase.execute )
-                blockID = result['blockID']
-
-        Result:
-            Output of frontend rendering
-        """
-
-        pass
-
-    def render_error(failure):
-        """Subclasses must override to render the failure.
-
-        In asynchronous frontend, since this method will be called as a
-        twisted.internet.defer.Deferred's callback. Implementations
-        should thus return result when finished.
-
-        blockID = failure.blockID
-        """
-
-        pass
-
-    def input_prompt(number=''):
-        """Returns the input prompt by subsituting into
-        self.input_prompt_template
-        """
-        pass
-
-    def output_prompt(number=''):
-        """Returns the output prompt by subsituting into
-        self.output_prompt_template
-        """
-
-        pass
-
-    def continuation_prompt():
-        """Returns the continuation prompt by subsituting into
-        self.continuation_prompt_template
-        """
-
-        pass
-
-    def is_complete(block):
-        """Returns True if block is complete, False otherwise."""
-
-        pass
-
-
-    def get_history_previous(current_block):
-        """Returns the block previous in  the history. Saves currentBlock if
-        the history_cursor is currently at the end of the input history"""
-        pass
-
-    def get_history_next():
-        """Returns the next block in the history."""
-
-        pass
-
-    def complete(self, line):
-        """Returns the list of possible completions, and the completed
-            line.
-
-        The input argument is the full line to be completed. This method
-        returns both the line completed as much as possible, and the list
-        of further possible completions (full words).
-        """
-        pass
-
-
-##############################################################################
-# Base class for all the frontends.
-##############################################################################
-
-class FrontEndBase(object):
-    """
-    FrontEndBase manages the state tasks for a CLI frontend:
-        - Input and output history management
-        - Input/continuation and output prompt generation
-
-    Some issues (due to possibly unavailable engine):
-        - How do we get the current cell number for the engine?
-        - How do we handle completions?
-    """
-
-    history_cursor = 0
-
-    input_prompt_template = string.Template(rc.prompt_in1)
-    output_prompt_template = string.Template(rc.prompt_out)
-    continuation_prompt_template = string.Template(rc.prompt_in2)
-
-    def __init__(self, shell=None, history=None):
-        self.shell = shell
-        if history is None:
-                self.history = FrontEndHistory(input_cache=[''])
-        else:
-            self.history = history
-
-
-    def input_prompt(self, number=''):
-        """Returns the current input prompt
-
-        It would be great to use ipython1.core.prompts.Prompt1 here
-        """
-        return self.input_prompt_template.safe_substitute({'number':number})
-
-
-    def continuation_prompt(self):
-        """Returns the current continuation prompt"""
-
-        return self.continuation_prompt_template.safe_substitute()
-
-    def output_prompt(self, number=''):
-        """Returns the output prompt for result"""
-
-        return self.output_prompt_template.safe_substitute({'number':number})
-
-
-    def is_complete(self, block):
-        """Determine if block is complete.
-
-        Parameters
-        block : string
-
-        Result
-        True if block can be sent to the engine without compile errors.
-        False otherwise.
-        """
-
-        try:
-            is_complete = codeop.compile_command(block.rstrip() + '\n\n',
-                            "<string>", "exec")
-        except:
-            return False
-
-        lines = block.split('\n')
-        return ((is_complete is not None)
-                    and (len(lines)==1 or str(lines[-1])==''))
-
-
-    def execute(self, block, blockID=None):
-        """Execute the block and return the result.
-
-        Parameters:
-            block : {str, AST}
-            blockID : any
-                Caller may provide an ID to identify this block.
-                result['blockID'] := blockID
-
-        Result:
-            Deferred result of self.interpreter.execute
-        """
-
-        if(not self.is_complete(block)):
-            raise Exception("Block is not compilable")
-
-        if(blockID == None):
-            blockID = uuid.uuid4()
-
-        try:
-            result = self.shell.execute(block)
-        except Exception as e:
-            e = self._add_block_id_for_failure(e, blockID=blockID)
-            e = self.update_cell_prompt(e, blockID=blockID)
-            e = self.render_error(e)
-        else:
-            result = self._add_block_id_for_result(result, blockID=blockID)
-            result = self.update_cell_prompt(result, blockID=blockID)
-            result = self.render_result(result)
-
-        return result
-
-
-    def _add_block_id_for_result(self, result, blockID):
-        """Add the blockID to result or failure. Unfortunatley, we have to
-        treat failures differently than result dicts.
-        """
-
-        result['blockID'] = blockID
-
-        return result
-
-    def _add_block_id_for_failure(self, failure, blockID):
-        """_add_block_id_for_failure"""
-        failure.blockID = blockID
-        return failure
-
-
-    def _add_history(self, result, block=None):
-        """Add block to the history"""
-
-        assert(block != None)
-        self.history.add_items([block])
-        self.history_cursor += 1
-
-        return result
-
-
-    def get_history_previous(self, current_block):
-        """ Returns previous history string and decrement history cursor.
-        """
-        command = self.history.get_history_item(self.history_cursor - 1)
-
-        if command is not None:
-            if(self.history_cursor+1 == len(self.history.input_cache)):
-                self.history.input_cache[self.history_cursor] = current_block
-            self.history_cursor -= 1
-        return command
-
-
-    def get_history_next(self):
-        """ Returns next history string and increment history cursor.
-        """
-        command = self.history.get_history_item(self.history_cursor+1)
-
-        if command is not None:
-            self.history_cursor += 1
-        return command
-
-    ###
-    # Subclasses probably want to override these methods...
-    ###
-
-    def update_cell_prompt(self, result, blockID=None):
-        """Subclass may override to update the input prompt for a block.
-
-        This method only really makes sens in asyncrhonous frontend.
-        Since this method will be called as a
-        twisted.internet.defer.Deferred's callback, implementations should
-        return result when finished.
-        """
-
-        raise NotImplementedError
-
-
-    def render_result(self, result):
-        """Subclasses must override to render result.
-
-        In asynchronous frontends, this method will be called as a
-        twisted.internet.defer.Deferred's callback. Implementations
-        should thus return result when finished.
-        """
-
-        raise NotImplementedError
-
-
-    def render_error(self, failure):
-        """Subclasses must override to render the failure.
-
-        In asynchronous frontends, this method will be called as a
-        twisted.internet.defer.Deferred's callback. Implementations
-        should thus return result when finished.
-        """
-
-        raise NotImplementedError
-

IPython/deathrow/oldfrontend/linefrontendbase.py

@@ -1,373 +0,0 b''
-"""
-Base front end class for all line-oriented frontends, rather than
-block-oriented.
-
-Currently this focuses on synchronous frontends.
-"""
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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 re
-
-import sys
-import codeop
-
-from frontendbase import FrontEndBase
-from IPython.kernel.core.interpreter import Interpreter
-
-def common_prefix(strings):
-    """ Given a list of strings, return the common prefix between all
-        these strings.
-    """
-    ref = strings[0]
-    prefix = ''
-    for size in range(len(ref)):
-        test_prefix = ref[:size+1]
-        for string in strings[1:]:
-            if not string.startswith(test_prefix):
-                return prefix
-        prefix = test_prefix
-
-    return prefix
-
-#-----------------------------------------------------------------------------
-# Base class for the line-oriented front ends
-#-----------------------------------------------------------------------------
-
-class LineFrontEndBase(FrontEndBase):
-    """ Concrete implementation of the FrontEndBase class. This is meant
-    to be the base class behind all the frontend that are line-oriented,
-    rather than block-oriented.
-    """
-
-    # We need to keep the prompt number, to be able to increment
-    # it when there is an exception.
-    prompt_number = 1
-
-    # We keep a reference to the last result: it helps testing and
-    # programatic control of the frontend.
-    last_result = dict(number=0)
-
-    # The last prompt displayed. Useful for continuation prompts.
-    last_prompt = ''
-
-    # The input buffer being edited
-    input_buffer = ''
-
-    # Set to true for debug output
-    debug = False
-
-    # A banner to print at startup
-    banner = None
-
-    #--------------------------------------------------------------------------
-    # FrontEndBase interface
-    #--------------------------------------------------------------------------
-
-    def __init__(self, shell=None, history=None, banner=None, *args, **kwargs):
-        if shell is None:
-            shell = Interpreter()
-        FrontEndBase.__init__(self, shell=shell, history=history)
-
-        if banner is not None:
-            self.banner = banner
-
-    def start(self):
-        """ Put the frontend in a state where it is ready for user
-            interaction.
-        """
-        if self.banner is not None:
-            self.write(self.banner, refresh=False)
-
-        self.new_prompt(self.input_prompt_template.substitute(number=1))
-
-
-    def complete(self, line):
-        """Complete line in engine's user_ns
-
-        Parameters
-        ----------
-        line : string
-
-        Returns
-        -------
-        The replacement for the line and the list of possible completions.
-        """
-        completions = self.shell.complete(line)
-        complete_sep =  re.compile('[\s\{\}\[\]\(\)\=]')
-        if completions:
-            prefix = common_prefix(completions)
-            residual = complete_sep.split(line)[:-1]
-            line = line[:-len(residual)] + prefix
-        return line, completions
-
-
-    def render_result(self, result):
-        """ Frontend-specific rendering of the result of a calculation
-        that has been sent to an engine.
-        """
-        if 'stdout' in result and result['stdout']:
-            self.write('\n' + result['stdout'])
-        if 'display' in result and result['display']:
-            self.write("%s%s\n" % (
-                            self.output_prompt_template.substitute(
-                                    number=result['number']),
-                            result['display']['pprint']
-                            ) )
-
-
-    def render_error(self, failure):
-        """ Frontend-specific rendering of error.
-        """
-        self.write('\n\n'+str(failure)+'\n\n')
-        return failure
-
-
-    def is_complete(self, string):
-        """ Check if a string forms a complete, executable set of
-        commands.
-
-        For the line-oriented frontend, multi-line code is not executed
-        as soon as it is complete: the users has to enter two line
-        returns.
-        """
-        if string in ('', '\n'):
-            # Prefiltering, eg through ipython0, may return an empty
-            # string although some operations have been accomplished. We
-            # thus want to consider an empty string as a complete
-            # statement.
-            return True
-        elif ( len(self.input_buffer.split('\n'))>2
-                        and not re.findall(r"\n[\t ]*\n[\t ]*$", string)):
-            return False
-        else:
-            self.capture_output()
-            try:
-                # Add line returns here, to make sure that the statement is
-                # complete (except if '\' was used).
-                # This should probably be done in a different place (like
-                # maybe 'prefilter_input' method? For now, this works.
-                clean_string = string.rstrip('\n')
-                if not clean_string.endswith('\\'): clean_string +='\n\n'
-                is_complete = codeop.compile_command(clean_string,
-                            "<string>", "exec")
-                self.release_output()
-            except Exception as e:
-                # XXX: Hack: return True so that the
-                # code gets executed and the error captured.
-                is_complete = True
-            return is_complete
-
-
-    def write(self, string, refresh=True):
-        """ Write some characters to the display.
-
-            Subclass should overide this method.
-
-            The refresh keyword argument is used in frontends with an
-            event loop, to choose whether the write should trigget an UI
-            refresh, and thus be syncrhonous, or not.
-        """
-        print >>sys.__stderr__, string
-
-
-    def execute(self, python_string, raw_string=None):
-        """ Stores the raw_string in the history, and sends the
-        python string to the interpreter.
-        """
-        if raw_string is None:
-            raw_string = python_string
-        # Create a false result, in case there is an exception
-        self.last_result = dict(number=self.prompt_number)
-
-        try:
-            try:
-                self.history.input_cache[-1] = raw_string.rstrip()
-                result = self.shell.execute(python_string)
-                self.last_result = result
-                self.render_result(result)
-            except:
-                self.show_traceback()
-        finally:
-            self.after_execute()
-
-
-    #--------------------------------------------------------------------------
-    # LineFrontEndBase interface
-    #--------------------------------------------------------------------------
-
-    def prefilter_input(self, string):
-        """ Prefilter the input to turn it in valid python.
-        """
-        string = string.replace('\r\n', '\n')
-        string = string.replace('\t', 4*' ')
-        # Clean the trailing whitespace
-        string = '\n'.join(l.rstrip()  for l in string.split('\n'))
-        return string
-
-
-    def after_execute(self):
-        """ All the operations required after an execution to put the
-            terminal back in a shape where it is usable.
-        """
-        self.prompt_number += 1
-        self.new_prompt(self.input_prompt_template.substitute(
-                            number=(self.last_result['number'] + 1)))
-        # Start a new empty history entry
-        self._add_history(None, '')
-        self.history_cursor = len(self.history.input_cache) - 1
-
-
-    def complete_current_input(self):
-        """ Do code completion on current line.
-        """
-        if self.debug:
-            print >>sys.__stdout__, "complete_current_input",
-        line = self.input_buffer
-        new_line, completions = self.complete(line)
-        if len(completions)>1:
-            self.write_completion(completions, new_line=new_line)
-        elif not line == new_line:
-            self.input_buffer = new_line
-        if self.debug:
-            print >>sys.__stdout__, 'line', line
-            print >>sys.__stdout__, 'new_line', new_line
-            print >>sys.__stdout__, completions
-
-
-    def get_line_width(self):
-        """ Return the width of the line in characters.
-        """
-        return 80
-
-
-    def write_completion(self, possibilities, new_line=None):
-        """ Write the list of possible completions.
-
-            new_line is the completed input line that should be displayed
-            after the completion are writen. If None, the input_buffer
-            before the completion is used.
-        """
-        if new_line is None:
-            new_line = self.input_buffer
-
-        self.write('\n')
-        max_len = len(max(possibilities, key=len)) + 1
-
-        # Now we check how much symbol we can put on a line...
-        chars_per_line = self.get_line_width()
-        symbols_per_line = max(1, chars_per_line/max_len)
-
-        pos = 1
-        completion_string = []
-        for symbol in possibilities:
-            if pos < symbols_per_line:
-                completion_string.append(symbol.ljust(max_len))
-                pos += 1
-            else:
-                completion_string.append(symbol.rstrip() + '\n')
-                pos = 1
-        self.write(''.join(completion_string))
-        self.new_prompt(self.input_prompt_template.substitute(
-                            number=self.last_result['number'] + 1))
-        self.input_buffer = new_line
-
-
-    def new_prompt(self, prompt):
-        """ Prints a prompt and starts a new editing buffer.
-
-            Subclasses should use this method to make sure that the
-            terminal is put in a state favorable for a new line
-            input.
-        """
-        self.input_buffer = ''
-        self.write(prompt)
-
-
-    def continuation_prompt(self):
-        """Returns the current continuation prompt.
-        """
-        return ("."*(len(self.last_prompt)-2) + ': ')
-
-
-    def execute_command(self, command, hidden=False):
-        """ Execute a command, not only in the model, but also in the
-            view, if any.
-        """
-        return self.shell.execute(command)
-
-    #--------------------------------------------------------------------------
-    # Private API
-    #--------------------------------------------------------------------------
-
-    def _on_enter(self, new_line_pos=0):
-        """ Called when the return key is pressed in a line editing
-            buffer.
-
-            Parameters
-            ----------
-            new_line_pos : integer, optional
-                Position of the new line to add, starting from the
-                end (0 adds a new line after the last line, -1 before
-                the last line...)
-
-            Returns
-            -------
-            True if execution is triggered
-        """
-        current_buffer = self.input_buffer
-        # XXX: This string replace is ugly, but there should be no way it
-        # fails.
-        prompt_less_buffer = re.sub('^' + self.continuation_prompt(),
-                '', current_buffer).replace('\n' + self.continuation_prompt(),
-                                            '\n')
-        cleaned_buffer = self.prefilter_input(prompt_less_buffer)
-        if self.is_complete(cleaned_buffer):
-            self.execute(cleaned_buffer, raw_string=current_buffer)
-            return True
-        else:
-            # Start a new line.
-            new_line_pos = -new_line_pos
-            lines = current_buffer.split('\n')[:-1]
-            prompt_less_lines = prompt_less_buffer.split('\n')
-            # Create the new line, with the continuation prompt, and the
-            # same amount of indent than the line above it.
-            new_line = self.continuation_prompt() + \
-                  self._get_indent_string('\n'.join(
-                                    prompt_less_lines[:new_line_pos-1]))
-            if len(lines) == 1:
-                # We are starting a first continuation line. Indent it.
-                new_line += '\t'
-            elif current_buffer[:-1].split('\n')[-1].rstrip().endswith(':'):
-                # The last line ends with ":", autoindent the new line.
-                new_line += '\t'
-
-            if new_line_pos == 0:
-                lines.append(new_line)
-            else:
-                lines.insert(new_line_pos, new_line)
-            self.input_buffer = '\n'.join(lines)
-
-
-    def _get_indent_string(self, string):
-        """ Return the string of whitespace that prefixes a line. Used to
-        add the right amount of indendation when creating a new line.
-        """
-        string = string.replace('\t', ' '*4)
-        string = string.split('\n')[-1]
-        indent_chars = len(string) - len(string.lstrip())
-        indent_string = '\t'*(indent_chars // 4) + \
-                            ' '*(indent_chars % 4)
-
-        return indent_string
-
-

IPython/deathrow/oldfrontend/prefilterfrontend.py

@@ -1,256 +0,0 b''
-"""
-Frontend class that uses IPython0 to prefilter the inputs.
-
-Using the IPython0 mechanism gives us access to the magics.
-
-This is a transitory class, used here to do the transition between
-ipython0 and ipython1. This class is meant to be short-lived as more
-functionnality is abstracted out of ipython0 in reusable functions and
-is added on the interpreter. This class can be a used to guide this
-refactoring.
-"""
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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 pydoc
-import os
-import re
-import __builtin__
-
-from IPython.core.iplib import InteractiveShell
-from IPython.kernel.core.redirector_output_trap import RedirectorOutputTrap
-
-from IPython.kernel.core.sync_traceback_trap import SyncTracebackTrap
-
-import IPython.utils.io
-
-from linefrontendbase import LineFrontEndBase, common_prefix
-
-#-----------------------------------------------------------------------------
-# Utility functions
-#-----------------------------------------------------------------------------
-
-def mk_system_call(system_call_function, command):
-    """ given a os.system replacement, and a leading string command,
-        returns a function that will execute the command with the given
-        argument string.
-    """
-    def my_system_call(args):
-        system_call_function("%s %s" % (command, args))
-
-    my_system_call.__doc__ = "Calls %s" % command
-    return my_system_call
-
-#-----------------------------------------------------------------------------
-# Frontend class using ipython0 to do the prefiltering.
-#-----------------------------------------------------------------------------
-
-class PrefilterFrontEnd(LineFrontEndBase):
-    """ Class that uses ipython0 to do prefilter the input, do the
-    completion and the magics.
-
-    The core trick is to use an ipython0 instance to prefilter the
-    input, and share the namespace between the interpreter instance used
-    to execute the statements and the ipython0 used for code
-    completion...
-    """
-
-    debug = False
-
-    def __init__(self, ipython0=None, *args, **kwargs):
-        """ Parameters
-            ----------
-
-            ipython0: an optional ipython0 instance to use for command
-            prefiltering and completion.
-        """
-        LineFrontEndBase.__init__(self, *args, **kwargs)
-        self.shell.output_trap = RedirectorOutputTrap(
-                            out_callback=self.write,
-                            err_callback=self.write,
-                                            )
-        self.shell.traceback_trap = SyncTracebackTrap(
-                        formatters=self.shell.traceback_trap.formatters,
-                            )
-
-        # Start the ipython0 instance:
-        self.save_output_hooks()
-        if ipython0 is None:
-            # Instanciate an IPython0 InteractiveShell to be able to use the
-            # prefiltering.
-            # Suppress all key input, to avoid waiting
-            def my_rawinput(x=None):
-                return '\n'
-            old_rawinput = __builtin__.raw_input
-            __builtin__.raw_input = my_rawinput
-            ipython0 = InteractiveShell(
-                parent=None, user_ns=self.shell.user_ns,
-                user_global_ns=self.shell.user_global_ns
-            )
-            __builtin__.raw_input = old_rawinput
-        self.ipython0 = ipython0
-        # Set the pager:
-        self.ipython0.set_hook('show_in_pager',
-                    lambda s, string: self.write("\n" + string))
-        self.ipython0.write = self.write
-        self._ip = _ip = self.ipython0
-        # Make sure the raw system call doesn't get called, as we don't
-        # have a stdin accessible.
-        self._ip.system = self.system_call
-        # XXX: Muck around with magics so that they work better
-        # in our environment
-        if not sys.platform.startswith('win'):
-            self.ipython0.magic_ls = mk_system_call(self.system_call,
-                                                                'ls -CF')
-        # And now clean up the mess created by ipython0
-        self.release_output()
-
-
-        if not 'banner' in kwargs and self.banner is None:
-            self.banner = self.ipython0.banner
-
-        # FIXME: __init__ and start should be two different steps
-        self.start()
-
-    #--------------------------------------------------------------------------
-    # FrontEndBase interface
-    #--------------------------------------------------------------------------
-
-    def show_traceback(self):
-        """ Use ipython0 to capture the last traceback and display it.
-        """
-        # Don't do the capture; the except_hook has already done some
-        # modifications to the IO streams, if we store them, we'll be
-        # storing the wrong ones.
-        #self.capture_output()
-        self.ipython0.showtraceback(tb_offset=-1)
-        self.release_output()
-
-
-    def execute(self, python_string, raw_string=None):
-        if self.debug:
-            print 'Executing Python code:', repr(python_string)
-        self.capture_output()
-        LineFrontEndBase.execute(self, python_string,
-                                    raw_string=raw_string)
-        self.release_output()
-
-
-    def save_output_hooks(self):
-        """ Store all the output hooks we can think of, to be able to
-        restore them.
-
-        We need to do this early, as starting the ipython0 instance will
-        screw ouput hooks.
-        """
-        self.__old_cout_write = Term.cout.write
-        self.__old_cerr_write = Term.cerr.write
-        self.__old_stdout = sys.stdout
-        self.__old_stderr= sys.stderr
-        self.__old_help_output = pydoc.help.output
-        self.__old_display_hook = sys.displayhook
-
-
-    def capture_output(self):
-        """ Capture all the output mechanisms we can think of.
-        """
-        self.save_output_hooks()
-        Term.cout.write = self.write
-        Term.cerr.write = self.write
-        sys.stdout = Term.cout
-        sys.stderr = Term.cerr
-        pydoc.help.output = self.shell.output_trap.out
-
-
-    def release_output(self):
-        """ Release all the different captures we have made.
-        """
-        Term.cout.write = self.__old_cout_write
-        Term.cerr.write = self.__old_cerr_write
-        sys.stdout = self.__old_stdout
-        sys.stderr = self.__old_stderr
-        pydoc.help.output = self.__old_help_output
-        sys.displayhook = self.__old_display_hook
-
-
-    def complete(self, line):
-        # FIXME: This should be factored out in the linefrontendbase
-        # method.
-        word = self._get_completion_text(line)
-        completions = self.ipython0.complete(word)
-        # FIXME: The proper sort should be done in the complete method.
-        key = lambda x: x.replace('_', '')
-        completions.sort(key=key)
-        if completions:
-            prefix = common_prefix(completions)
-            line = line[:-len(word)] + prefix
-        return line, completions
-
-    #--------------------------------------------------------------------------
-    # LineFrontEndBase interface
-    #--------------------------------------------------------------------------
-
-    def prefilter_input(self, input_string):
-        """ Using IPython0 to prefilter the commands to turn them
-        in executable statements that are valid Python strings.
-        """
-        input_string = LineFrontEndBase.prefilter_input(self, input_string)
-        filtered_lines = []
-        # The IPython0 prefilters sometime produce output. We need to
-        # capture it.
-        self.capture_output()
-        self.last_result = dict(number=self.prompt_number)
-
-        try:
-            try:
-                for line in input_string.split('\n'):
-                    pf = self.ipython0.prefilter_manager.prefilter_lines
-                    filtered_lines.append(pf(line, False).rstrip())
-            except:
-                # XXX: probably not the right thing to do.
-                self.ipython0.showsyntaxerror()
-                self.after_execute()
-        finally:
-            self.release_output()
-
-        # Clean up the trailing whitespace, to avoid indentation errors
-        filtered_string = '\n'.join(filtered_lines)
-        return filtered_string
-
-    #--------------------------------------------------------------------------
-    # PrefilterFrontEnd interface
-    #--------------------------------------------------------------------------
-
-    def system_call(self, command_string):
-        """ Allows for frontend to define their own system call, to be
-            able capture output and redirect input.
-        """
-        return os.system(command_string)
-
-    def do_exit(self):
-        """ Exit the shell, cleanup and save the history.
-        """
-        self.ipython0.atexit_operations()
-
-    def _get_completion_text(self, line):
-        """ Returns the text to be completed by breaking the line at specified
-        delimiters.
-        """
-        # Break at: spaces, '=', all parentheses (except if balanced).
-        # FIXME2: In the future, we need to make the implementation similar to
-        # that in the 'pyreadline' module (modes/basemode.py) where we break at
-        # each delimiter and try to complete the residual line, until we get a
-        # successful list of completions.
-        expression = '\s|=|,|:|\((?!.*\))|\[(?!.*\])|\{(?!.*\})'
-        complete_sep = re.compile(expression)
-        text = complete_sep.split(line)[-1]
-        return text

IPython/deathrow/oldfrontend/process/__init__.py

@@ -1,19 +0,0 b''
-"""
-Package for dealing for process execution in a callback environment, in a
-portable way.
-
-killable_process.py is a wrapper of subprocess.Popen that allows the
-subprocess and its children to be killed in a reliable way, including
-under windows.
-
-winprocess.py is required by killable_process.py to kill processes under
-windows.
-
-piped_process.py wraps process execution with callbacks to print output,
-in a non-blocking way. It can be used to interact with a subprocess in eg
-a GUI event loop.
-"""
-
-from pipedprocess import PipedProcess
-
-

IPython/deathrow/oldfrontend/process/killableprocess.py

@@ -1,184 +0,0 b''
-# Addapted from killableprocess.py.
-#______________________________________________________________________________
-#
-# killableprocess - subprocesses which can be reliably killed
-#
-# Parts of this module are copied from the subprocess.py file contained
-# in the Python distribution.
-#
-# Copyright (c) 2003-2004 by Peter Astrand <[e-mail]>
-#
-# Additions and modifications written by Benjamin Smedberg
-# <[e-mail]> are Copyright (c) 2006 by the Mozilla Foundation
-# <http://www.mozilla.org/>
-#
-# By obtaining, using, and/or copying this software and/or its
-# associated documentation, you agree that you have read, understood,
-# and will comply with the following terms and conditions:
-#
-# Permission to use, copy, modify, and distribute this software and
-# its associated documentation for any purpose and without fee is
-# hereby granted, provided that the above copyright notice appears in
-# all copies, and that both that copyright notice and this permission
-# notice appear in supporting documentation, and that the name of the
-# author not be used in advertising or publicity pertaining to
-# distribution of the software without specific, written prior
-# permission.
-#
-# THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
-# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
-# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR
-# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
-# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
-# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
-# WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-r"""killableprocess - Subprocesses which can be reliably killed
-
-This module is a subclass of the builtin "subprocess" module. It allows
-processes that launch subprocesses to be reliably killed on Windows (via the Popen.kill() method.
-
-It also adds a timeout argument to Wait() for a limited period of time before
-forcefully killing the process.
-
-Note: On Windows, this module requires Windows 2000 or higher (no support for
-Windows 95, 98, or NT 4.0). It also requires ctypes, which is bundled with
-Python 2.5+ or available from http://python.net/crew/theller/ctypes/
-"""
-
-import subprocess
-from subprocess import PIPE
-import sys
-import os
-import types
-
-try:
-    from subprocess import CalledProcessError
-except ImportError:
-    # Python 2.4 doesn't implement CalledProcessError
-    class CalledProcessError(Exception):
-        """This exception is raised when a process run by check_call() returns
-        a non-zero exit status. The exit status will be stored in the
-        returncode attribute."""
-        def __init__(self, returncode, cmd):
-            self.returncode = returncode
-            self.cmd = cmd
-        def __str__(self):
-            return "Command '%s' returned non-zero exit status %d" % (self.cmd, self.returncode)
-
-mswindows = (sys.platform == "win32")
-
-skip = False
-
-if mswindows:
-    import platform
-    if platform.uname()[3] == '' or platform.uname()[3] > '6.0.6000':
-        # Killable process does not work under vista when starting for
-        # something else than cmd.
-        skip = True
-    else:
-        import winprocess
-else:
-    import signal
-
-if not mswindows:
-    def DoNothing(*args):
-        pass
-
-
-if skip:
- Popen = subprocess.Popen
-else:
- class Popen(subprocess.Popen):
-    if not mswindows:
-        # Override __init__ to set a preexec_fn
-        def __init__(self, *args, **kwargs):
-            if len(args) >= 7:
-                raise Exception("Arguments preexec_fn and after must be passed by keyword.")
-
-            real_preexec_fn = kwargs.pop("preexec_fn", None)
-            def setpgid_preexec_fn():
-                os.setpgid(0, 0)
-                if real_preexec_fn:
-                    apply(real_preexec_fn)
-
-            kwargs['preexec_fn'] = setpgid_preexec_fn
-
-            subprocess.Popen.__init__(self, *args, **kwargs)
-
-    if mswindows:
-        def _execute_child(self, args, executable, preexec_fn, close_fds,
-                           cwd, env, universal_newlines, startupinfo,
-                           creationflags, shell,
-                           p2cread, p2cwrite,
-                           c2pread, c2pwrite,
-                           errread, errwrite):
-            if not isinstance(args, types.StringTypes):
-                args = subprocess.list2cmdline(args)
-
-            if startupinfo is None:
-                startupinfo = winprocess.STARTUPINFO()
-
-            if None not in (p2cread, c2pwrite, errwrite):
-                startupinfo.dwFlags |= winprocess.STARTF_USESTDHANDLES
-
-                startupinfo.hStdInput = int(p2cread)
-                startupinfo.hStdOutput = int(c2pwrite)
-                startupinfo.hStdError = int(errwrite)
-            if shell:
-                startupinfo.dwFlags |= winprocess.STARTF_USESHOWWINDOW
-                startupinfo.wShowWindow = winprocess.SW_HIDE
-                comspec = os.environ.get("COMSPEC", "cmd.exe")
-                args = comspec + " /c " + args
-
-            # We create a new job for this process, so that we can kill
-            # the process and any sub-processes
-            self._job = winprocess.CreateJobObject()
-
-            creationflags |= winprocess.CREATE_SUSPENDED
-            creationflags |= winprocess.CREATE_UNICODE_ENVIRONMENT
-
-            hp, ht, pid, tid = winprocess.CreateProcess(
-                executable, args,
-                None, None, # No special security
-                1, # Must inherit handles!
-                creationflags,
-                winprocess.EnvironmentBlock(env),
-                cwd, startupinfo)
-
-            self._child_created = True
-            self._handle = hp
-            self._thread = ht
-            self.pid = pid
-
-            # XXX: A try/except to fix UAC-related problems under
-            # Windows Vista, when reparenting jobs.
-            try:
-                winprocess.AssignProcessToJobObject(self._job, hp)
-            except WindowsError:
-                pass
-            winprocess.ResumeThread(ht)
-
-            if p2cread is not None:
-                p2cread.Close()
-            if c2pwrite is not None:
-                c2pwrite.Close()
-            if errwrite is not None:
-                errwrite.Close()
-
-    def kill(self, group=True):
-        """Kill the process. If group=True, all sub-processes will also be killed."""
-        if mswindows:
-            if group:
-                winprocess.TerminateJobObject(self._job, 127)
-            else:
-                winprocess.TerminateProcess(self._handle, 127)
-            self.returncode = 127
-        else:
-            if group:
-                os.killpg(self.pid, signal.SIGKILL)
-            else:
-                os.kill(self.pid, signal.SIGKILL)
-            self.returncode = -9
-
-

IPython/deathrow/oldfrontend/process/pipedprocess.py

@@ -1,74 +0,0 b''
-# encoding: utf-8
-"""
-Object for encapsulating process execution by using callbacks for stdout,
-stderr and stdin.
-"""
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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
-#-------------------------------------------------------------------------------
-from killableprocess import Popen, PIPE
-from threading import Thread
-from time import sleep
-import os
-
-class PipedProcess(Thread):
-    """ Class that encapsulates process execution by using callbacks for
-        stdout, stderr and stdin, and providing a reliable way of
-        killing it.
-    """
-
-    def __init__(self, command_string, out_callback,
-                        end_callback=None,):
-        """ command_string: the command line executed to start the
-        process.
-
-        out_callback: the python callable called on stdout/stderr.
-
-        end_callback: an optional callable called when the process
-        finishes.
-
-        These callbacks are called from a different thread as the
-        thread from which is started.
-        """
-        self.command_string = command_string
-        self.out_callback = out_callback
-        self.end_callback = end_callback
-        Thread.__init__(self)
-
-
-    def run(self):
-        """ Start the process and hook up the callbacks.
-        """
-        env = os.environ
-        env['TERM'] = 'xterm'
-        process = Popen(self.command_string + ' 2>&1', shell=True,
-                                env=env,
-                                universal_newlines=True,
-                                stdout=PIPE, stdin=PIPE, )
-        self.process = process
-        while True:
-            out_char = process.stdout.read(1)
-            if out_char == '':
-                if process.poll() is not None:
-                    # The process has finished
-                    break
-                else:
-                    # The process is not giving any interesting
-                    # output. No use polling it immediatly.
-                    sleep(0.1)
-            else:
-                self.out_callback(out_char)
-
-        if self.end_callback is not None:
-            self.end_callback()
-
-

IPython/deathrow/oldfrontend/process/winprocess.py

@@ -1,264 +0,0 b''
-# A module to expose various thread/process/job related structures and
-# methods from kernel32
-#
-# The MIT License
-#
-# Copyright (c) 2006 the Mozilla Foundation <http://www.mozilla.org>
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the "Software"),
-# to deal in the Software without restriction, including without limitation
-# the rights to use, copy, modify, merge, publish, distribute, sublicense,
-# and/or sell copies of the Software, and to permit persons to whom the
-# Software is furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-# DEALINGS IN THE SOFTWARE.
-
-from ctypes import c_void_p, POINTER, sizeof, Structure, windll, WinError, WINFUNCTYPE
-from ctypes.wintypes import BOOL, BYTE, DWORD, HANDLE, LPCWSTR, LPWSTR, UINT, WORD
-
-LPVOID = c_void_p
-LPBYTE = POINTER(BYTE)
-LPDWORD = POINTER(DWORD)
-
-SW_HIDE = 0
-
-def ErrCheckBool(result, func, args):
-    """errcheck function for Windows functions that return a BOOL True
-    on success"""
-    if not result:
-        raise WinError()
-    return args
-
-# CloseHandle()
-
-CloseHandleProto = WINFUNCTYPE(BOOL, HANDLE)
-CloseHandle = CloseHandleProto(("CloseHandle", windll.kernel32))
-CloseHandle.errcheck = ErrCheckBool
-
-# AutoHANDLE
-
-class AutoHANDLE(HANDLE):
-    """Subclass of HANDLE which will call CloseHandle() on deletion."""
-    def Close(self):
-        if self.value:
-            CloseHandle(self)
-            self.value = 0
-    
-    def __del__(self):
-        self.Close()
-
-    def __int__(self):
-        return self.value
-
-def ErrCheckHandle(result, func, args):
-    """errcheck function for Windows functions that return a HANDLE."""
-    if not result:
-        raise WinError()
-    return AutoHANDLE(result)
-
-# PROCESS_INFORMATION structure
-
-class PROCESS_INFORMATION(Structure):
-    _fields_ = [("hProcess", HANDLE),
-                ("hThread", HANDLE),
-                ("dwProcessID", DWORD),
-                ("dwThreadID", DWORD)]
-
-    def __init__(self):
-        Structure.__init__(self)
-        
-        self.cb = sizeof(self)
-
-LPPROCESS_INFORMATION = POINTER(PROCESS_INFORMATION)
-
-# STARTUPINFO structure
-
-class STARTUPINFO(Structure):
-    _fields_ = [("cb", DWORD),
-                ("lpReserved", LPWSTR),
-                ("lpDesktop", LPWSTR),
-                ("lpTitle", LPWSTR),
-                ("dwX", DWORD),
-                ("dwY", DWORD),
-                ("dwXSize", DWORD),
-                ("dwYSize", DWORD),
-                ("dwXCountChars", DWORD),
-                ("dwYCountChars", DWORD),
-                ("dwFillAttribute", DWORD),
-                ("dwFlags", DWORD),
-                ("wShowWindow", WORD),
-                ("cbReserved2", WORD),
-                ("lpReserved2", LPBYTE),
-                ("hStdInput", HANDLE),
-                ("hStdOutput", HANDLE),
-                ("hStdError", HANDLE)
-                ]
-LPSTARTUPINFO = POINTER(STARTUPINFO)
-
-STARTF_USESHOWWINDOW    = 0x01
-STARTF_USESIZE          = 0x02
-STARTF_USEPOSITION      = 0x04
-STARTF_USECOUNTCHARS    = 0x08
-STARTF_USEFILLATTRIBUTE = 0x10
-STARTF_RUNFULLSCREEN    = 0x20
-STARTF_FORCEONFEEDBACK  = 0x40
-STARTF_FORCEOFFFEEDBACK = 0x80
-STARTF_USESTDHANDLES    = 0x100
-
-# EnvironmentBlock
-
-class EnvironmentBlock:
-    """An object which can be passed as the lpEnv parameter of CreateProcess.
-    It is initialized with a dictionary."""
-
-    def __init__(self, dict):
-        if not dict:
-            self._as_parameter_ = None
-        else:
-            values = ["%s=%s" % (key, value)
-                      for (key, value) in dict.iteritems()]
-            values.append("")
-            self._as_parameter_ = LPCWSTR("\0".join(values))
-        
-# CreateProcess()
-
-CreateProcessProto = WINFUNCTYPE(BOOL,                  # Return type
-                                 LPCWSTR,               # lpApplicationName
-                                 LPWSTR,                # lpCommandLine
-                                 LPVOID,                # lpProcessAttributes
-                                 LPVOID,                # lpThreadAttributes
-                                 BOOL,                  # bInheritHandles
-                                 DWORD,                 # dwCreationFlags
-                                 LPVOID,                # lpEnvironment
-                                 LPCWSTR,               # lpCurrentDirectory
-                                 LPSTARTUPINFO,         # lpStartupInfo
-                                 LPPROCESS_INFORMATION  # lpProcessInformation
-                                 )
-
-CreateProcessFlags = ((1, "lpApplicationName", None),
-                      (1, "lpCommandLine"),
-                      (1, "lpProcessAttributes", None),
-                      (1, "lpThreadAttributes", None),
-                      (1, "bInheritHandles", True),
-                      (1, "dwCreationFlags", 0),
-                      (1, "lpEnvironment", None),
-                      (1, "lpCurrentDirectory", None),
-                      (1, "lpStartupInfo"),
-                      (2, "lpProcessInformation"))
-
-def ErrCheckCreateProcess(result, func, args):
-    ErrCheckBool(result, func, args)
-    # return a tuple (hProcess, hThread, dwProcessID, dwThreadID)
-    pi = args[9]
-    return AutoHANDLE(pi.hProcess), AutoHANDLE(pi.hThread), pi.dwProcessID, pi.dwThreadID
-
-CreateProcess = CreateProcessProto(("CreateProcessW", windll.kernel32),
-                                   CreateProcessFlags)
-CreateProcess.errcheck = ErrCheckCreateProcess
-
-CREATE_BREAKAWAY_FROM_JOB = 0x01000000
-CREATE_DEFAULT_ERROR_MODE = 0x04000000
-CREATE_NEW_CONSOLE = 0x00000010
-CREATE_NEW_PROCESS_GROUP = 0x00000200
-CREATE_NO_WINDOW = 0x08000000
-CREATE_SUSPENDED = 0x00000004
-CREATE_UNICODE_ENVIRONMENT = 0x00000400
-DEBUG_ONLY_THIS_PROCESS = 0x00000002
-DEBUG_PROCESS = 0x00000001
-DETACHED_PROCESS = 0x00000008
-
-# CreateJobObject()
-
-CreateJobObjectProto = WINFUNCTYPE(HANDLE,             # Return type
-                                   LPVOID,             # lpJobAttributes
-                                   LPCWSTR             # lpName
-                                   )
-
-CreateJobObjectFlags = ((1, "lpJobAttributes", None),
-                        (1, "lpName", None))
-
-CreateJobObject = CreateJobObjectProto(("CreateJobObjectW", windll.kernel32),
-                                       CreateJobObjectFlags)
-CreateJobObject.errcheck = ErrCheckHandle
-
-# AssignProcessToJobObject()
-
-AssignProcessToJobObjectProto = WINFUNCTYPE(BOOL,      # Return type
-                                            HANDLE,    # hJob
-                                            HANDLE     # hProcess
-                                            )
-AssignProcessToJobObjectFlags = ((1, "hJob"),
-                                 (1, "hProcess"))
-AssignProcessToJobObject = AssignProcessToJobObjectProto(
-    ("AssignProcessToJobObject", windll.kernel32),
-    AssignProcessToJobObjectFlags)
-AssignProcessToJobObject.errcheck = ErrCheckBool
-
-# ResumeThread()
-
-def ErrCheckResumeThread(result, func, args):
-    if result == -1:
-        raise WinError()
-
-    return args
-
-ResumeThreadProto = WINFUNCTYPE(DWORD,      # Return type
-                                HANDLE      # hThread
-                                )
-ResumeThreadFlags = ((1, "hThread"),)
-ResumeThread = ResumeThreadProto(("ResumeThread", windll.kernel32),
-                                 ResumeThreadFlags)
-ResumeThread.errcheck = ErrCheckResumeThread
-
-# TerminateJobObject()
-
-TerminateJobObjectProto = WINFUNCTYPE(BOOL,   # Return type
-                                      HANDLE, # hJob
-                                      UINT    # uExitCode
-                                      )
-TerminateJobObjectFlags = ((1, "hJob"),
-                           (1, "uExitCode", 127))
-TerminateJobObject = TerminateJobObjectProto(
-    ("TerminateJobObject", windll.kernel32),
-    TerminateJobObjectFlags)
-TerminateJobObject.errcheck = ErrCheckBool
-
-# WaitForSingleObject()
-
-WaitForSingleObjectProto = WINFUNCTYPE(DWORD,  # Return type
-                                       HANDLE, # hHandle
-                                       DWORD,  # dwMilliseconds
-                                       )
-WaitForSingleObjectFlags = ((1, "hHandle"),
-                            (1, "dwMilliseconds", -1))
-WaitForSingleObject = WaitForSingleObjectProto(
-    ("WaitForSingleObject", windll.kernel32),
-    WaitForSingleObjectFlags)
-
-INFINITE = -1
-WAIT_TIMEOUT = 0x0102
-WAIT_OBJECT_0 = 0x0
-WAIT_ABANDONED = 0x0080
-
-# GetExitCodeProcess()
-
-GetExitCodeProcessProto = WINFUNCTYPE(BOOL,    # Return type
-                                      HANDLE,  # hProcess
-                                      LPDWORD, # lpExitCode
-                                      )
-GetExitCodeProcessFlags = ((1, "hProcess"),
-                           (2, "lpExitCode"))
-GetExitCodeProcess = GetExitCodeProcessProto(
-    ("GetExitCodeProcess", windll.kernel32),
-    GetExitCodeProcessFlags)
-GetExitCodeProcess.errcheck = ErrCheckBool

IPython/deathrow/oldfrontend/tests/test_asyncfrontendbase.py

@@ -1,106 +0,0 b''
-# encoding: utf-8
-"""This file contains unittests for the asyncfrontendbase module."""
-
-#---------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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
-#---------------------------------------------------------------------------
-
-from twisted.trial import unittest
-
-from IPython.frontend.asyncfrontendbase import AsyncFrontEndBase
-from IPython.frontend import frontendbase
-from IPython.kernel.engineservice import EngineService
-from IPython.testing.parametric import Parametric, parametric
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-class FrontEndCallbackChecker(AsyncFrontEndBase):
-    """FrontEndBase subclass for checking callbacks"""
-    def __init__(self, engine=None, history=None):
-        super(FrontEndCallbackChecker, self).__init__(engine=engine,
-                                                    history=history)
-        self.updateCalled = False
-        self.renderResultCalled = False
-        self.renderErrorCalled = False
-
-    def update_cell_prompt(self, result, blockID=None):
-        self.updateCalled = True
-        return result
-
-    def render_result(self, result):
-        self.renderResultCalled = True
-        return result
-
-    def render_error(self, failure):
-        self.renderErrorCalled = True
-        return failure
-
-
-class TestAsyncFrontendBase(unittest.TestCase):
-    def setUp(self):
-        """Setup the EngineService and FrontEndBase"""
-
-        self.fb = FrontEndCallbackChecker(engine=EngineService())
-
-    def test_implements_IFrontEnd(self):
-        self.assert_(frontendbase.IFrontEnd.implementedBy(
-                                    AsyncFrontEndBase))
-
-    def test_is_complete_returns_False_for_incomplete_block(self):
-        block = """def test(a):"""
-        self.assert_(self.fb.is_complete(block) == False)
-
-    def test_is_complete_returns_True_for_complete_block(self):
-        block = """def test(a): pass"""
-        self.assert_(self.fb.is_complete(block))
-        block = """a=3"""
-        self.assert_(self.fb.is_complete(block))
-
-    def test_blockID_added_to_result(self):
-        block = """3+3"""
-        d = self.fb.execute(block, blockID='TEST_ID')
-        d.addCallback(lambda r: self.assert_(r['blockID']=='TEST_ID'))
-        return d
-
-    def test_blockID_added_to_failure(self):
-        block = "raise Exception()"
-        d = self.fb.execute(block,blockID='TEST_ID')
-        d.addErrback(lambda f: self.assert_(f.blockID=='TEST_ID'))
-        return d
-
-    def test_callbacks_added_to_execute(self):
-        d = self.fb.execute("10+10")
-        d.addCallback(lambda r: self.assert_(self.fb.updateCalled and self.fb.renderResultCalled))
-        return d
-
-    def test_error_callback_added_to_execute(self):
-        """Test that render_error called on execution error."""
-
-        d = self.fb.execute("raise Exception()")
-        d.addErrback(lambda f: self.assert_(self.fb.renderErrorCalled))
-        return d
-
-    def test_history_returns_expected_block(self):
-        """Make sure history browsing doesn't fail."""
-
-        blocks = ["a=1","a=2","a=3"]
-        d = self.fb.execute(blocks[0])
-        d.addCallback(lambda _: self.fb.execute(blocks[1]))
-        d.addCallback(lambda _: self.fb.execute(blocks[2]))
-        d.addCallback(lambda _: self.assert_(self.fb.get_history_previous("")==blocks[-2]))
-        d.addCallback(lambda _: self.assert_(self.fb.get_history_previous("")==blocks[-3]))
-        d.addCallback(lambda _: self.assert_(self.fb.get_history_next()==blocks[-2]))
-        return d
-
-    def test_history_returns_none_at_startup(self):
-        self.assert_(self.fb.get_history_previous("")==None)
-        self.assert_(self.fb.get_history_next()==None)

IPython/deathrow/oldfrontend/tests/test_frontendbase.py

@@ -1,32 +0,0 b''
-# encoding: utf-8
-"""
-Test the basic functionality of frontendbase.
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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.
-#-------------------------------------------------------------------------------
-
-from IPython.frontend.frontendbase import FrontEndBase
-
-def test_iscomplete():
-    """ Check that is_complete works.
-    """
-    f = FrontEndBase()
-    assert f.is_complete('(a + a)')
-    assert not f.is_complete('(a + a')
-    assert f.is_complete('1')
-    assert not f.is_complete('1 + ')
-    assert not f.is_complete('1 + \n\n')
-    assert f.is_complete('if True:\n  print 1\n')
-    assert not f.is_complete('if True:\n  print 1')
-    assert f.is_complete('def f():\n  print 1\n')
-
-if __name__ == '__main__':
-    test_iscomplete()
-

IPython/deathrow/oldfrontend/tests/test_linefrontend.py

@@ -1,37 +0,0 b''
-# encoding: utf-8
-"""
-Test the LineFrontEnd
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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.
-#-------------------------------------------------------------------------------
-
-from IPython.frontend.linefrontendbase import LineFrontEndBase
-from copy import deepcopy
-import nose.tools as nt
-
-class ConcreteLineFrontEnd(LineFrontEndBase):
-    """ A concrete class to test the LineFrontEndBase.
-    """
-    def capture_output(self):
-        pass
-
-    def release_output(self):
-        pass
-
-
-def test_is_complete():
-    """ Tests line completion heuristic.
-    """
-    frontend = ConcreteLineFrontEnd()
-    yield nt.assert_true, not frontend.is_complete('for x in \\')
-    yield nt.assert_true, not frontend.is_complete('for x in (1, ):')
-    yield nt.assert_true, frontend.is_complete('for x in (1, ):\n  pass')
-
-

IPython/deathrow/oldfrontend/tests/test_prefilterfrontend.py

@@ -1,268 +0,0 b''
-# encoding: utf-8
-"""
-Test process execution and IO redirection.
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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.
-#-------------------------------------------------------------------------------
-
-from copy import copy, deepcopy
-from cStringIO import StringIO
-import string
-import sys
-
-from nose.tools import assert_equal
-
-from IPython.frontend.prefilterfrontend import PrefilterFrontEnd
-from IPython.testing.globalipapp import get_ipython
-
-#-----------------------------------------------------------------------------
-# Support utilities
-#-----------------------------------------------------------------------------
-
-class TestPrefilterFrontEnd(PrefilterFrontEnd):
-
-    input_prompt_template = string.Template('')
-    output_prompt_template = string.Template('')
-    banner = ''
-
-    def __init__(self):
-        self.out = StringIO()
-        PrefilterFrontEnd.__init__(self)
-        # Some more code for isolation (yeah, crazy)
-        self._on_enter()
-        self.out.flush()
-        self.out.reset()
-        self.out.truncate()
-
-    def write(self, string, *args, **kwargs):
-       self.out.write(string)
-
-    def _on_enter(self):
-        self.input_buffer += '\n'
-        PrefilterFrontEnd._on_enter(self)
-
-
-def isolate_ipython0(func):
-    """ Decorator to isolate execution that involves an iptyhon0.
-
-        Notes
-        -----
-
-        Apply only to functions with no arguments. Nose skips functions
-        with arguments.
-    """
-    def my_func():
-        ip0 = get_ipython()
-        if ip0 is None:
-            return func()
-        # We have a real ipython running...
-        user_ns = ip0.user_ns
-        user_global_ns = ip0.user_global_ns
-
-        # Previously the isolation was attempted with a deep copy of the user
-        # dicts, but we found cases where this didn't work correctly. I'm not
-        # quite sure why, but basically it did damage the user namespace, such
-        # that later tests stopped working correctly.  Instead we use a simpler
-        # approach, just computing the list of added keys to the namespace and
-        # eliminating those afterwards.  Existing keys that may have been
-        # modified remain modified.  So far this has proven to be robust.
-
-        # Compute set of old local/global keys
-        old_locals = set(user_ns.keys())
-        old_globals = set(user_global_ns.keys())
-        try:
-            out = func()
-        finally:
-            # Find new keys, and if any, remove them
-            new_locals = set(user_ns.keys()) - old_locals
-            new_globals = set(user_global_ns.keys()) - old_globals
-            for k in new_locals:
-                del user_ns[k]
-            for k in new_globals:
-                del user_global_ns[k]
-        return out
-
-    my_func.__name__ = func.__name__
-    return my_func
-
-#-----------------------------------------------------------------------------
-# Tests
-#-----------------------------------------------------------------------------
-
-@isolate_ipython0
-def test_execution():
-    """ Test execution of a command.
-    """
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = 'print(1)'
-    f._on_enter()
-    out_value = f.out.getvalue()
-    assert_equal(out_value, '1\n')
-
-
-@isolate_ipython0
-def test_multiline():
-    """ Test execution of a multiline command.
-    """
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = 'if True:'
-    f._on_enter()
-    f.input_buffer += 'print 1'
-    f._on_enter()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, ''
-    f._on_enter()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, '1\n'
-    f = TestPrefilterFrontEnd()
-    f.input_buffer='(1 +'
-    f._on_enter()
-    f.input_buffer += '0)'
-    f._on_enter()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, ''
-    f._on_enter()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, '1\n'
-
-
-@isolate_ipython0
-def test_capture():
-    """ Test the capture of output in different channels.
-    """
-    # Test on the OS-level stdout, stderr.
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = \
-            'import os; out=os.fdopen(1, "w"); out.write("1") ; out.flush()'
-    f._on_enter()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, '1'
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = \
-            'import os; out=os.fdopen(2, "w"); out.write("1") ; out.flush()'
-    f._on_enter()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, '1'
-
-
-@isolate_ipython0
-def test_magic():
-    """ Test the magic expansion and history.
-
-        This test is fairly fragile and will break when magics change.
-    """
-    f = TestPrefilterFrontEnd()
-    # Before checking the interactive namespace, make sure it's clear (it can
-    # otherwise pick up things stored in the user's local db)
-    f.input_buffer += '%reset -f'
-    f._on_enter()
-    f.complete_current_input()
-    # Now, run the %who magic and check output
-    f.input_buffer += '%who'
-    f._on_enter()
-    out_value = f.out.getvalue()
-    assert_equal(out_value, 'Interactive namespace is empty.\n')
-
-
-@isolate_ipython0
-def test_help():
-    """ Test object inspection.
-    """
-    f = TestPrefilterFrontEnd()
-    f.input_buffer += "def f():"
-    f._on_enter()
-    f.input_buffer += "'foobar'"
-    f._on_enter()
-    f.input_buffer += "pass"
-    f._on_enter()
-    f._on_enter()
-    f.input_buffer += "f?"
-    f._on_enter()
-    assert 'traceback' not in f.last_result
-    ## XXX: ipython doctest magic breaks this. I have no clue why
-    #out_value = f.out.getvalue()
-    #assert out_value.split()[-1] == 'foobar'
-
-
-@isolate_ipython0
-def test_completion_simple():
-    """ Test command-line completion on trivial examples.
-    """
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = 'zzza = 1'
-    f._on_enter()
-    f.input_buffer = 'zzzb = 2'
-    f._on_enter()
-    f.input_buffer = 'zz'
-    f.complete_current_input()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, '\nzzza zzzb '
-    yield assert_equal, f.input_buffer, 'zzz'
-
-
-@isolate_ipython0
-def test_completion_parenthesis():
-    """ Test command-line completion when a parenthesis is open.
-    """
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = 'zzza = 1'
-    f._on_enter()
-    f.input_buffer = 'zzzb = 2'
-    f._on_enter()
-    f.input_buffer = 'map(zz'
-    f.complete_current_input()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, '\nzzza zzzb '
-    yield assert_equal, f.input_buffer, 'map(zzz'
-
-
-@isolate_ipython0
-def test_completion_indexing():
-    """ Test command-line completion when indexing on objects.
-    """
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = 'a = [0]'
-    f._on_enter()
-    f.input_buffer = 'a[0].'
-    f.complete_current_input()
-
-    if sys.version_info[:2] >= (2,6):
-        # In Python 2.6, ints picked up a few non __ methods, so now there are
-        # no completions.
-        assert_equal(f.input_buffer, 'a[0].')
-    else:
-        # Right answer for 2.4/2.5
-        assert_equal(f.input_buffer, 'a[0].__')
-
-
-@isolate_ipython0
-def test_completion_equal():
-    """ Test command-line completion when the delimiter is "=", not " ".
-    """
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = 'a=1.'
-    f.complete_current_input()
-    if sys.version_info[:2] >= (2,6):
-        # In Python 2.6, ints picked up a few non __ methods, so now there are
-        # no completions.
-        assert_equal(f.input_buffer, 'a=1.')
-    else:
-        # Right answer for 2.4/2.5
-        assert_equal(f.input_buffer, 'a=1.__')
-
-
-if __name__ == '__main__':
-    test_magic()
-    test_help()
-    test_execution()
-    test_multiline()
-    test_capture()
-    test_completion_simple()
-    test_completion_complex()

IPython/deathrow/oldfrontend/tests/test_process.py

@@ -1,68 +0,0 b''
-# encoding: utf-8
-"""
-Test process execution and IO redirection.
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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.
-#-----------------------------------------------------------------------------
-
-from cStringIO import StringIO
-from time import sleep
-import sys
-
-from IPython.frontend.process import PipedProcess
-from IPython.testing import decorators as dec
-
-
-def test_capture_out():
-    """ A simple test to see if we can execute a process and get the output.
-    """
-    s = StringIO()
-    p = PipedProcess('echo 1', out_callback=s.write, )
-    p.start()
-    p.join()
-    result = s.getvalue().rstrip()
-    assert result == '1'
-
-
-def test_io():
-    """ Checks that we can send characters on stdin to the process.
-    """
-    s = StringIO()
-    p = PipedProcess(sys.executable + ' -c "a = raw_input(); print a"',
-                            out_callback=s.write, )
-    p.start()
-    test_string = '12345\n'
-    while not hasattr(p, 'process'):
-        sleep(0.1)
-    p.process.stdin.write(test_string)
-    p.join()
-    result = s.getvalue()
-    assert result == test_string
-
-
[e-mail]_win32
-def test_kill():
-    """ Check that we can kill a process, and its subprocess.
-    """
-    s = StringIO()
-    p = PipedProcess(sys.executable + ' -c "a = raw_input();"',
-                            out_callback=s.write, )
-    p.start()
-    while not hasattr(p, 'process'):
-        sleep(0.1)
-    p.process.kill()
-    assert p.process.poll() is not None
-
-
-if __name__ == '__main__':
-    test_capture_out()
-    test_io()
-    test_kill()
-

IPython/deathrow/oldfrontend/wx/console_widget.py

@@ -1,625 +0,0 b''
-# encoding: utf-8
-"""
-A Wx widget to act as a console and input commands.
-
-This widget deals with prompts and provides an edit buffer
-restricted to after the last prompt.
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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 wx
-import wx.stc  as  stc
-
-from wx.py import editwindow
-import time
-import sys
-import string
-
-LINESEP = '\n'
-if sys.platform == 'win32':
-    LINESEP = '\n\r'
-
-import re
-
-# FIXME: Need to provide an API for non user-generated display on the
-# screen: this should not be editable by the user.
-#-------------------------------------------------------------------------------
-# Constants
-#-------------------------------------------------------------------------------
-_COMPLETE_BUFFER_MARKER = 31
-_ERROR_MARKER = 30
-_INPUT_MARKER = 29
-
-_DEFAULT_SIZE = 10
-if sys.platform == 'darwin':
-    _DEFAULT_SIZE = 12
-
-_DEFAULT_STYLE = {
-    #background definition
-    'default'     : 'size:%d' % _DEFAULT_SIZE,
-    'bracegood'   : 'fore:#00AA00,back:#000000,bold',
-    'bracebad'    : 'fore:#FF0000,back:#000000,bold',
-
-    # Edge column: a number of None
-    'edge_column' : -1,
-
-    # properties for the various Python lexer styles
-    'comment'       : 'fore:#007F00',
-    'number'        : 'fore:#007F7F',
-    'string'        : 'fore:#7F007F,italic',
-    'char'          : 'fore:#7F007F,italic',
-    'keyword'       : 'fore:#00007F,bold',
-    'triple'        : 'fore:#7F0000',
-    'tripledouble'  : 'fore:#7F0000',
-    'class'         : 'fore:#0000FF,bold,underline',
-    'def'           : 'fore:#007F7F,bold',
-    'operator'      : 'bold',
-
-    # Default colors
-    'trace'         : '#FAFAF1', # Nice green
-    'stdout'        : '#FDFFD3', # Nice yellow
-    'stderr'        : '#FFF1F1', # Nice red
-
-    # Default scintilla settings
-    'antialiasing'  : True,
-    'carret_color'  : 'BLACK',
-    'background_color' :'WHITE',
-
-    #prompt definition
-    'prompt_in1'    : \
-        '\n\x01\x1b[0;34m\x02In [\x01\x1b[1;34m\x02$number\x01\x1b[0;34m\x02]: \x01\x1b[0m\x02',
-
-    'prompt_out': \
-        '\x01\x1b[0;31m\x02Out[\x01\x1b[1;31m\x02$number\x01\x1b[0;31m\x02]: \x01\x1b[0m\x02',
-    }
-
-# new style numbers
-_STDOUT_STYLE = 15
-_STDERR_STYLE = 16
-_TRACE_STYLE  = 17
-
-
-# system colors
-#SYS_COLOUR_BACKGROUND = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BACKGROUND)
-
-# Translation table from ANSI escape sequences to color.
-ANSI_STYLES = {'0;30': [0, 'BLACK'],            '0;31': [1, 'RED'],
-               '0;32': [2, 'GREEN'],           '0;33': [3, 'BROWN'],
-               '0;34': [4, 'BLUE'],            '0;35': [5, 'PURPLE'],
-               '0;36': [6, 'CYAN'],            '0;37': [7, 'LIGHT GREY'],
-               '1;30': [8, 'DARK GREY'],       '1;31': [9, 'RED'],
-               '1;32': [10, 'SEA GREEN'],      '1;33': [11, 'YELLOW'],
-               '1;34': [12, 'LIGHT BLUE'],     '1;35':
-                                                 [13, 'MEDIUM VIOLET RED'],
-               '1;36': [14, 'LIGHT STEEL BLUE'], '1;37': [15, 'YELLOW']}
-
-# XXX: Maybe one day we should factor this code with coloransi. Right now
-# coloransi is hard to reuse and makes our code more complex.
-
-#we define platform specific fonts
-if wx.Platform == '__WXMSW__':
-    FACES = { 'times': 'Times New Roman',
-                'mono' : 'Courier New',
-                'helv' : 'Arial',
-                'other': 'Comic Sans MS',
-                'size' : 10,
-                'size2': 8,
-                }
-elif wx.Platform == '__WXMAC__':
-    FACES = { 'times': 'Times New Roman',
-                'mono' : 'Monaco',
-                'helv' : 'Arial',
-                'other': 'Comic Sans MS',
-                'size' : 10,
-                'size2': 8,
-                }
-else:
-    FACES = { 'times': 'Times',
-                'mono' : 'Courier',
-                'helv' : 'Helvetica',
-                'other': 'new century schoolbook',
-                'size' : 10,
-                'size2': 8,
-                }
-
-
-#-----------------------------------------------------------------------------
-# The console widget class
-#-----------------------------------------------------------------------------
-
-class ConsoleWidget(editwindow.EditWindow):
-    """ Specialized styled text control view for console-like workflow.
-
-        This widget is mainly interested in dealing with the prompt and
-        keeping the cursor inside the editing line.
-    """
-
-    # This is where the title captured from the ANSI escape sequences are
-    # stored.
-    title = 'Console'
-
-    # Last prompt printed
-    last_prompt = ''
-
-    # The buffer being edited.
-    def _set_input_buffer(self, string):
-        self.SetSelection(self.current_prompt_pos, self.GetLength())
-        self.ReplaceSelection(string)
-        self.GotoPos(self.GetLength())
-
-    def _get_input_buffer(self):
-        """ Returns the text in current edit buffer.
-        """
-        input_buffer = self.GetTextRange(self.current_prompt_pos,
-                                                self.GetLength())
-        input_buffer = input_buffer.replace(LINESEP, '\n')
-        return input_buffer
-
-    input_buffer = property(_get_input_buffer, _set_input_buffer)
-
-    style = _DEFAULT_STYLE.copy()
-
-    # Translation table from ANSI escape sequences to color. Override
-    # this to specify your colors.
-    ANSI_STYLES = ANSI_STYLES.copy()
-
-    # Font faces
-    faces = FACES.copy()
-
-    # Store the last time a refresh was done
-    _last_refresh_time = 0
-
-    #--------------------------------------------------------------------------
-    # Public API
-    #--------------------------------------------------------------------------
-
-    def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition,
-                        size=wx.DefaultSize, style=wx.WANTS_CHARS, ):
-        editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
-        self.configure_scintilla()
-        # Track if 'enter' key as ever been processed
-        # This variable will only be reallowed until key goes up
-        self.enter_catched = False
-        self.current_prompt_pos = 0
-
-        self.Bind(wx.EVT_KEY_DOWN, self._on_key_down)
-        self.Bind(wx.EVT_KEY_UP, self._on_key_up)
-
-
-    def write(self, text, refresh=True):
-        """ Write given text to buffer, while translating the ansi escape
-            sequences.
-        """
-        # XXX: do not put print statements to sys.stdout/sys.stderr in
-        # this method, the print statements will call this method, as
-        # you will end up with an infinit loop
-        title = self.title_pat.split(text)
-        if len(title)>1:
-            self.title = title[-2]
-
-        text = self.title_pat.sub('', text)
-        segments = self.color_pat.split(text)
-        segment = segments.pop(0)
-        self.GotoPos(self.GetLength())
-        self.StartStyling(self.GetLength(), 0xFF)
-        try:
-            self.AppendText(segment)
-        except UnicodeDecodeError:
-            # XXX: Do I really want to skip the exception?
-            pass
-
-        if segments:
-            for ansi_tag, text in zip(segments[::2], segments[1::2]):
-                self.StartStyling(self.GetLength(), 0xFF)
-                try:
-                    self.AppendText(text)
-                except UnicodeDecodeError:
-                    # XXX: Do I really want to skip the exception?
-                    pass
-
-                if ansi_tag not in self.ANSI_STYLES:
-                    style = 0
-                else:
-                    style = self.ANSI_STYLES[ansi_tag][0]
-
-                self.SetStyling(len(text), style)
-
-        self.GotoPos(self.GetLength())
-        if refresh:
-            current_time = time.time()
-            if current_time - self._last_refresh_time > 0.03:
-                if sys.platform == 'win32':
-                    wx.SafeYield()
-                else:
-                    wx.Yield()
-                #    self.ProcessEvent(wx.PaintEvent())
-                self._last_refresh_time = current_time
-
-
-    def new_prompt(self, prompt):
-        """ Prints a prompt at start of line, and move the start of the
-            current block there.
-
-            The prompt can be given with ascii escape sequences.
-        """
-        self.write(prompt, refresh=False)
-        # now we update our cursor giving end of prompt
-        self.current_prompt_pos = self.GetLength()
-        self.current_prompt_line = self.GetCurrentLine()
-        self.EnsureCaretVisible()
-        self.last_prompt = prompt
-
-
-    def continuation_prompt(self):
-        """ Returns the current continuation prompt.
-            We need to implement this method here to deal with the
-            ascii escape sequences cleaning up.
-        """
-        # ASCII-less prompt
-        ascii_less = ''.join(self.color_pat.split(self.last_prompt)[2::2])
-        return "."*(len(ascii_less)-2) + ': '
-
-
-    def scroll_to_bottom(self):
-        maxrange = self.GetScrollRange(wx.VERTICAL)
-        self.ScrollLines(maxrange)
-
-
-    def pop_completion(self, possibilities, offset=0):
-        """ Pops up an autocompletion menu. Offset is the offset
-            in characters of the position at which the menu should
-            appear, relativ to the cursor.
-        """
-        self.AutoCompSetIgnoreCase(False)
-        self.AutoCompSetAutoHide(False)
-        self.AutoCompSetMaxHeight(len(possibilities))
-        self.AutoCompShow(offset, " ".join(possibilities))
-
-
-    def get_line_width(self):
-        """ Return the width of the line in characters.
-        """
-        return self.GetSize()[0]/self.GetCharWidth()
-
-
-    def configure_scintilla(self):
-        """ Set up all the styling option of the embedded scintilla
-            widget.
-        """
-        p = self.style.copy()
-
-        # Marker for complete buffer.
-        self.MarkerDefine(_COMPLETE_BUFFER_MARKER, stc.STC_MARK_BACKGROUND,
-                                background=p['trace'])
-
-        # Marker for current input buffer.
-        self.MarkerDefine(_INPUT_MARKER, stc.STC_MARK_BACKGROUND,
-                                background=p['stdout'])
-        # Marker for tracebacks.
-        self.MarkerDefine(_ERROR_MARKER, stc.STC_MARK_BACKGROUND,
-                                background=p['stderr'])
-
-        self.SetEOLMode(stc.STC_EOL_LF)
-
-        # Ctrl"+" or Ctrl "-" can be used to zoomin/zoomout the text inside
-        # the widget
-        self.CmdKeyAssign(ord('+'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
-        self.CmdKeyAssign(ord('-'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
-        # Also allow Ctrl Shift "=" for poor non US keyboard users.
-        self.CmdKeyAssign(ord('='), stc.STC_SCMOD_CTRL|stc.STC_SCMOD_SHIFT,
-                                            stc.STC_CMD_ZOOMIN)
-
-        # Keys: we need to clear some of the keys the that don't play
-        # well with a console.
-        self.CmdKeyClear(ord('D'), stc.STC_SCMOD_CTRL)
-        self.CmdKeyClear(ord('L'), stc.STC_SCMOD_CTRL)
-        self.CmdKeyClear(ord('T'), stc.STC_SCMOD_CTRL)
-        self.CmdKeyClear(ord('A'), stc.STC_SCMOD_CTRL)
-
-        self.SetEOLMode(stc.STC_EOL_CRLF)
-        self.SetWrapMode(stc.STC_WRAP_CHAR)
-        self.SetWrapMode(stc.STC_WRAP_WORD)
-        self.SetBufferedDraw(True)
-
-        self.SetUseAntiAliasing(p['antialiasing'])
-
-        self.SetLayoutCache(stc.STC_CACHE_PAGE)
-        self.SetUndoCollection(False)
-        self.SetUseTabs(True)
-        self.SetIndent(4)
-        self.SetTabWidth(4)
-
-        # we don't want scintilla's autocompletion to choose
-        # automaticaly out of a single choice list, as we pop it up
-        # automaticaly
-        self.AutoCompSetChooseSingle(False)
-        self.AutoCompSetMaxHeight(10)
-        # XXX: this doesn't seem to have an effect.
-        self.AutoCompSetFillUps('\n')
-
-        self.SetMargins(3, 3) #text is moved away from border with 3px
-        # Suppressing Scintilla margins
-        self.SetMarginWidth(0, 0)
-        self.SetMarginWidth(1, 0)
-        self.SetMarginWidth(2, 0)
-
-        # Xterm escape sequences
-        self.color_pat = re.compile('\x01?\x1b\[(.*?)m\x02?')
-        self.title_pat = re.compile('\x1b]0;(.*?)\x07')
-
-        # styles
-
-        self.SetCaretForeground(p['carret_color'])
-
-        background_color = p['background_color']
-
-        if 'default' in p:
-            if 'back' not in p['default']:
-                p['default'] += ',back:%s' % background_color
-            if 'size' not in p['default']:
-                p['default'] += ',size:%s' % self.faces['size']
-            if 'face' not in p['default']:
-                p['default'] += ',face:%s' % self.faces['mono']
-
-            self.StyleSetSpec(stc.STC_STYLE_DEFAULT, p['default'])
-        else:
-            self.StyleSetSpec(stc.STC_STYLE_DEFAULT,
-                            "fore:%s,back:%s,size:%d,face:%s"
-                            % (self.ANSI_STYLES['0;30'][1],
-                               background_color,
-                               self.faces['size'], self.faces['mono']))
-
-        self.StyleClearAll()
-
-        # XXX: two lines below are usefull if not using the lexer
-        #for style in self.ANSI_STYLES.values():
-        #    self.StyleSetSpec(style[0], "bold,fore:%s" % style[1])
-
-        # prompt definition
-        self.prompt_in1 = p['prompt_in1']
-        self.prompt_out = p['prompt_out']
-
-        self.output_prompt_template = string.Template(self.prompt_out)
-        self.input_prompt_template = string.Template(self.prompt_in1)
-
-        self.StyleSetSpec(_STDOUT_STYLE, p['stdout'])
-        self.StyleSetSpec(_STDERR_STYLE, p['stderr'])
-        self.StyleSetSpec(_TRACE_STYLE, p['trace'])
-        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT, p['bracegood'])
-        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD, p['bracebad'])
-        self.StyleSetSpec(stc.STC_P_COMMENTLINE, p['comment'])
-        self.StyleSetSpec(stc.STC_P_NUMBER, p['number'])
-        self.StyleSetSpec(stc.STC_P_STRING, p['string'])
-        self.StyleSetSpec(stc.STC_P_CHARACTER, p['char'])
-        self.StyleSetSpec(stc.STC_P_WORD, p['keyword'])
-        self.StyleSetSpec(stc.STC_P_WORD2, p['keyword'])
-        self.StyleSetSpec(stc.STC_P_TRIPLE, p['triple'])
-        self.StyleSetSpec(stc.STC_P_TRIPLEDOUBLE, p['tripledouble'])
-        self.StyleSetSpec(stc.STC_P_CLASSNAME, p['class'])
-        self.StyleSetSpec(stc.STC_P_DEFNAME, p['def'])
-        self.StyleSetSpec(stc.STC_P_OPERATOR, p['operator'])
-        self.StyleSetSpec(stc.STC_P_COMMENTBLOCK, p['comment'])
-
-        edge_column = p['edge_column']
-        if edge_column is not None and edge_column > 0:
-            #we add a vertical line to console widget
-            self.SetEdgeMode(stc.STC_EDGE_LINE)
-            self.SetEdgeColumn(edge_column)
-
-
-    #--------------------------------------------------------------------------
-    # EditWindow API
-    #--------------------------------------------------------------------------
-
-    def OnUpdateUI(self, event):
-        """ Override the OnUpdateUI of the EditWindow class, to prevent
-            syntax highlighting both for faster redraw, and for more
-            consistent look and feel.
-        """
-
-
-    #--------------------------------------------------------------------------
-    # Private API
-    #--------------------------------------------------------------------------
-
-    def _on_key_down(self, event, skip=True):
-        """ Key press callback used for correcting behavior for
-            console-like interfaces: the cursor is constraint to be after
-            the last prompt.
-
-            Return True if event as been catched.
-        """
-        catched = True
-        # XXX: Would the right way to do this be to have a
-        #  dictionary at the instance level associating keys with
-        #  callbacks? How would we deal with inheritance? And Do the
-        #  different callbacks share local variables?
-
-        # Intercept some specific keys.
-        key_code = event.GetKeyCode()
-        if key_code == ord('L') and event.ControlDown() :
-            self.scroll_to_bottom()
-        elif key_code == ord('K') and event.ControlDown() :
-            self.input_buffer = ''
-        elif key_code == ord('A') and event.ControlDown() :
-            self.GotoPos(self.GetLength())
-            self.SetSelectionStart(self.current_prompt_pos)
-            self.SetSelectionEnd(self.GetCurrentPos())
-            catched = True
-        elif key_code == ord('E') and event.ControlDown() :
-            self.GotoPos(self.GetLength())
-            catched = True
-        elif key_code == wx.WXK_PAGEUP:
-            self.ScrollPages(-1)
-        elif key_code == wx.WXK_PAGEDOWN:
-            self.ScrollPages(1)
-        elif key_code == wx.WXK_HOME:
-            self.GotoPos(self.GetLength())
-        elif key_code == wx.WXK_END:
-            self.GotoPos(self.GetLength())
-        elif key_code == wx.WXK_UP and event.ShiftDown():
-            self.ScrollLines(-1)
-        elif key_code == wx.WXK_DOWN and event.ShiftDown():
-            self.ScrollLines(1)
-        else:
-            catched = False
-
-        if self.AutoCompActive():
-            event.Skip()
-        else:
-            if key_code in (13, wx.WXK_NUMPAD_ENTER):
-                # XXX: not catching modifiers, to be wx2.6-compatible
-                catched = True
-                if not self.enter_catched:
-                    self.CallTipCancel()
-                    if event.ShiftDown():
-                        # Try to force execution
-                        self.GotoPos(self.GetLength())
-                        self.write('\n' + self.continuation_prompt(),
-                                        refresh=False)
-                        self._on_enter()
-                    else:
-                        self._on_enter()
-                    self.enter_catched = True
-
-            elif key_code == wx.WXK_HOME:
-                if not event.ShiftDown():
-                    self.GotoPos(self.current_prompt_pos)
-                    catched = True
-                else:
-                    # FIXME: This behavior is not ideal: if the selection
-                    # is already started, it will jump.
-                    self.SetSelectionStart(self.current_prompt_pos)
-                    self.SetSelectionEnd(self.GetCurrentPos())
-                    catched = True
-
-            elif key_code == wx.WXK_UP:
-                if self.GetCurrentLine() > self.current_prompt_line:
-                    if self.GetCurrentLine() == self.current_prompt_line + 1 \
-                            and self.GetColumn(self.GetCurrentPos()) < \
-                                self.GetColumn(self.current_prompt_pos):
-                        self.GotoPos(self.current_prompt_pos)
-                    else:
-                        event.Skip()
-                catched = True
-
-            elif key_code in (wx.WXK_LEFT, wx.WXK_BACK):
-                if not self._keep_cursor_in_buffer(self.GetCurrentPos() - 1):
-                    event.Skip()
-                catched = True
-
-            elif key_code == wx.WXK_RIGHT:
-                if not self._keep_cursor_in_buffer(self.GetCurrentPos() + 1):
-                    event.Skip()
-                catched = True
-
-
-            elif key_code == wx.WXK_DELETE:
-                if not self._keep_cursor_in_buffer(self.GetCurrentPos() - 1):
-                    event.Skip()
-                catched = True
-
-            if skip and not catched:
-                # Put the cursor back in the edit region
-                if not self._keep_cursor_in_buffer():
-                    if not (self.GetCurrentPos() == self.GetLength()
-                                and key_code == wx.WXK_DELETE):
-                        event.Skip()
-                    catched = True
-
-        return catched
-
-
-    def _on_key_up(self, event, skip=True):
-        """ If cursor is outside the editing region, put it back.
-        """
-        if skip:
-            event.Skip()
-        self._keep_cursor_in_buffer()
-
-
-    # XXX:  I need to avoid the problem of having an empty glass;
-    def _keep_cursor_in_buffer(self, pos=None):
-        """ Checks if the cursor is where it is allowed to be. If not,
-            put it back.
-
-            Returns
-            -------
-            cursor_moved: Boolean
-                whether or not the cursor was moved by this routine.
-
-            Notes
-            ------
-                WARNING: This does proper checks only for horizontal
-                movements.
-        """
-        if pos is None:
-            current_pos = self.GetCurrentPos()
-        else:
-            current_pos = pos
-        if  current_pos < self.current_prompt_pos:
-            self.GotoPos(self.current_prompt_pos)
-            return True
-        line_num = self.LineFromPosition(current_pos)
-        if not current_pos > self.GetLength():
-            line_pos = self.GetColumn(current_pos)
-        else:
-            line_pos = self.GetColumn(self.GetLength())
-        line = self.GetLine(line_num)
-        # Jump the continuation prompt
-        continuation_prompt = self.continuation_prompt()
-        if ( line.startswith(continuation_prompt)
-                     and line_pos < len(continuation_prompt)):
-            if line_pos < 2:
-                # We are at the beginning of the line, trying to move
-                # forward: jump forward.
-                self.GotoPos(current_pos + 1 +
-                                    len(continuation_prompt) - line_pos)
-            else:
-                # Jump back up
-                self.GotoPos(self.GetLineEndPosition(line_num-1))
-            return True
-        elif ( current_pos > self.GetLineEndPosition(line_num)
-                        and not current_pos == self.GetLength()):
-            # Jump to next line
-            self.GotoPos(current_pos + 1 +
-                                    len(continuation_prompt))
-            return True
-
-        # We re-allow enter event processing
-        self.enter_catched = False
-        return False
-
-
-if __name__ == '__main__':
-    # Some simple code to test the console widget.
-    class MainWindow(wx.Frame):
-        def __init__(self, parent, id, title):
-            wx.Frame.__init__(self, parent, id, title, size=(300, 250))
-            self._sizer = wx.BoxSizer(wx.VERTICAL)
-            self.console_widget = ConsoleWidget(self)
-            self._sizer.Add(self.console_widget, 1, wx.EXPAND)
-            self.SetSizer(self._sizer)
-            self.SetAutoLayout(1)
-            self.Show(True)
-
-    app = wx.PySimpleApp()
-    w = MainWindow(None, wx.ID_ANY, 'ConsoleWidget')
-    w.SetSize((780, 460))
-    w.Show()
-
-    app.MainLoop()
-
-

IPython/deathrow/oldfrontend/wx/ipythonx.py

@@ -1,118 +0,0 b''
-"""
-Entry point for a simple application giving a graphical frontend to
-ipython.
-"""
-
-try:
-    import wx
-except ImportError as e:
-    e.args[0] = """%s
-________________________________________________________________________________
-You need wxPython to run this application.
-""" % e.args[0]
-    raise e
-
-from wx_frontend import WxController
-import __builtin__
-
-
-class IPythonXController(WxController):
-    """ Sub class of WxController that adds some application-specific
-        bindings.
-    """
-
-    debug = False
-
-    def __init__(self, *args, **kwargs):
-        WxController.__init__(self, *args, **kwargs)
-        self.ipython0.ask_exit = self.do_exit
-        # Scroll to top
-        maxrange = self.GetScrollRange(wx.VERTICAL)
-        self.ScrollLines(-maxrange)
-
-
-    def _on_key_down(self, event, skip=True):
-        # Intercept Ctrl-D to quit
-        if event.KeyCode == ord('D') and event.ControlDown() and \
-                self.input_buffer == '' and \
-                self._input_state == 'readline':
-            wx.CallAfter(self.ask_exit)
-        else:
-            WxController._on_key_down(self, event, skip=skip)
-
-
-    def ask_exit(self):
-        """ Ask the user whether to exit.
-        """
-        self._input_state = 'subprocess'
-        self.write('\n', refresh=False)
-        self.capture_output()
-        self.ipython0.exit()
-        self.release_output()
-        if not self.ipython0.exit_now:
-            wx.CallAfter(self.new_prompt,
-                         self.input_prompt_template.substitute(
-                                number=self.last_result['number'] + 1))
-        else:
-            wx.CallAfter(wx.GetApp().Exit)
-        self.write('Exiting ...', refresh=False)
-
-
-    def do_exit(self):
-        """ Exits the interpreter, kills the windows.
-        """
-        WxController.do_exit(self)
-        self.release_output()
-        wx.CallAfter(wx.Exit)
-
-
-
-class IPythonX(wx.Frame):
-    """ Main frame of the IPythonX app.
-    """
-
-    def __init__(self, parent, id, title, debug=False):
-        wx.Frame.__init__(self, parent, id, title, size=(300,250))
-        self._sizer = wx.BoxSizer(wx.VERTICAL)
-        self.shell = IPythonXController(self, debug=debug)
-        self._sizer.Add(self.shell, 1, wx.EXPAND)
-        self.SetSizer(self._sizer)
-        self.SetAutoLayout(1)
-        self.Show(True)
-        wx.EVT_CLOSE(self, self.on_close)
-
-
-    def on_close(self, event):
-        """ Called on closing the windows.
-
-            Stops the event loop, to close all the child windows.
-        """
-        wx.CallAfter(wx.Exit)
-
-
-def main():
-    from optparse import OptionParser
-    usage = """usage: %prog [options]
-
-Simple graphical frontend to IPython, using WxWidgets."""
-    parser = OptionParser(usage=usage)
-    parser.add_option("-d", "--debug",
-                    action="store_true", dest="debug", default=False,
-                    help="Enable debug message for the wx frontend.")
-
-    options, args = parser.parse_args()
-
-    # Clear the options, to avoid having the ipython0 instance complain
-    import sys
-    sys.argv = sys.argv[:1]
-
-    app = wx.PySimpleApp()
-    frame = IPythonX(None, wx.ID_ANY, 'IPythonX', debug=options.debug)
-    frame.shell.SetFocus()
-    frame.shell.app = app
-    frame.SetSize((680, 460))
-
-    app.MainLoop()
-
-if __name__ == '__main__':
-    main()

IPython/deathrow/oldfrontend/wx/wx_frontend.py

@@ -1,602 +0,0 b''
-# encoding: utf-8 -*- test-case-name:
-# FIXME: Need to add tests.
-# ipython1.frontend.wx.tests.test_wx_frontend -*-
-
-"""Classes to provide a Wx frontend to the
-IPython.kernel.core.interpreter.
-
-This class inherits from ConsoleWidget, that provides a console-like
-widget to provide a text-rendering widget suitable for a terminal.
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#       Copyright (C) 2008-2011  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
-#-------------------------------------------------------------------------------
-
-# Major library imports
-import re
-import __builtin__
-import sys
-from threading import Lock
-
-import wx
-from wx import stc
-
-# Ipython-specific imports.
-from IPython.frontend.process import PipedProcess
-from console_widget import ConsoleWidget, _COMPLETE_BUFFER_MARKER, \
-    _ERROR_MARKER, _INPUT_MARKER
-from IPython.frontend.prefilterfrontend import PrefilterFrontEnd
-
-#-------------------------------------------------------------------------------
-# Classes to implement the Wx frontend
-#-------------------------------------------------------------------------------
-class WxController(ConsoleWidget, PrefilterFrontEnd):
-    """Classes to provide a Wx frontend to the
-    IPython.kernel.core.interpreter.
-
-    This class inherits from ConsoleWidget, that provides a console-like
-    widget to provide a text-rendering widget suitable for a terminal.
-    """
-
-    # Print debug info on what is happening to the console.
-    debug = False
-
-    # The title of the terminal, as captured through the ANSI escape
-    # sequences.
-    def _set_title(self, title):
-            return self.Parent.SetTitle(title)
-
-    def _get_title(self):
-            return self.Parent.GetTitle()
-
-    title = property(_get_title, _set_title)
-
-
-    # The buffer being edited.
-    # We are duplicating the definition here because of multiple
-    # inheritence
-    def _set_input_buffer(self, string):
-        ConsoleWidget._set_input_buffer(self, string)
-        self._colorize_input_buffer()
-
-    def _get_input_buffer(self):
-        """ Returns the text in current edit buffer.
-        """
-        return ConsoleWidget._get_input_buffer(self)
-
-    input_buffer = property(_get_input_buffer, _set_input_buffer)
-
-
-    #--------------------------------------------------------------------------
-    # Private Attributes
-    #--------------------------------------------------------------------------
-
-    # A flag governing the behavior of the input. Can be:
-    #
-    #       'readline' for readline-like behavior with a prompt
-    #            and an edit buffer.
-    #       'raw_input' similar to readline, but triggered by a raw-input
-    #           call. Can be used by subclasses to act differently.
-    #       'subprocess' for sending the raw input directly to a
-    #           subprocess.
-    #       'buffering' for buffering of the input, that will be used
-    #           when the input state switches back to another state.
-    _input_state = 'readline'
-
-    # Attribute to store reference to the pipes of a subprocess, if we
-    # are running any.
-    _running_process = False
-
-    # A queue for writing fast streams to the screen without flooding the
-    # event loop
-    _out_buffer = []
-
-    # A lock to lock the _out_buffer to make sure we don't empty it
-    # while it is being swapped
-    _out_buffer_lock = Lock()
-
-    # The different line markers used to higlight the prompts.
-    _markers = dict()
-
-    #--------------------------------------------------------------------------
-    # Public API
-    #--------------------------------------------------------------------------
-
-    def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize,
-                 style=wx.CLIP_CHILDREN|wx.WANTS_CHARS,
-                 styledef=None,
-                 *args, **kwds):
-        """ Create Shell instance.
-
-            Parameters
-            -----------
-            styledef : dict, optional
-                styledef is the dictionary of options used to define the
-                style.
-        """
-        if styledef is not None:
-            self.style = styledef
-        ConsoleWidget.__init__(self, parent, id, pos, size, style)
-        PrefilterFrontEnd.__init__(self, **kwds)
-
-        # Stick in our own raw_input:
-        self.ipython0.raw_input = self.raw_input
-
-        # A time for flushing the write buffer
-        BUFFER_FLUSH_TIMER_ID = 100
-        self._buffer_flush_timer = wx.Timer(self, BUFFER_FLUSH_TIMER_ID)
-        wx.EVT_TIMER(self, BUFFER_FLUSH_TIMER_ID, self._buffer_flush)
-
-        if 'debug' in kwds:
-            self.debug = kwds['debug']
-            kwds.pop('debug')
-
-        # Inject self in namespace, for debug
-        if self.debug:
-            self.shell.user_ns['self'] = self
-        # Inject our own raw_input in namespace
-        self.shell.user_ns['raw_input'] = self.raw_input
-
-    def raw_input(self, prompt=''):
-        """ A replacement from python's raw_input.
-        """
-        self.new_prompt(prompt)
-        self._input_state = 'raw_input'
-        if hasattr(self, '_cursor'):
-            del self._cursor
-        self.SetCursor(wx.StockCursor(wx.CURSOR_CROSS))
-        self.__old_on_enter = self._on_enter
-        event_loop = wx.EventLoop()
-        def my_on_enter():
-            event_loop.Exit()
-        self._on_enter = my_on_enter
-        # XXX: Running a separate event_loop. Ugly.
-        event_loop.Run()
-        self._on_enter = self.__old_on_enter
-        self._input_state = 'buffering'
-        self._cursor = wx.BusyCursor()
-        return self.input_buffer.rstrip('\n')
-
-
-    def system_call(self, command_string):
-        self._input_state = 'subprocess'
-        event_loop = wx.EventLoop()
-        def _end_system_call():
-            self._input_state = 'buffering'
-            self._running_process = False
-            event_loop.Exit()
-
-        self._running_process = PipedProcess(command_string,
-                    out_callback=self.buffered_write,
-                    end_callback = _end_system_call)
-        self._running_process.start()
-        # XXX: Running a separate event_loop. Ugly.
-        event_loop.Run()
-        # Be sure to flush the buffer.
-        self._buffer_flush(event=None)
-
-
-    def do_calltip(self):
-        """ Analyse current and displays useful calltip for it.
-        """
-        if self.debug:
-            print >>sys.__stdout__, "do_calltip"
-        separators =  re.compile('[\s\{\}\[\]\(\)\= ,:]')
-        symbol = self.input_buffer
-        symbol_string = separators.split(symbol)[-1]
-        base_symbol_string = symbol_string.split('.')[0]
-        if base_symbol_string in self.shell.user_ns:
-            symbol = self.shell.user_ns[base_symbol_string]
-        elif base_symbol_string in self.shell.user_global_ns:
-            symbol = self.shell.user_global_ns[base_symbol_string]
-        elif base_symbol_string in __builtin__.__dict__:
-            symbol = __builtin__.__dict__[base_symbol_string]
-        else:
-            return False
-        try:
-            for name in symbol_string.split('.')[1:] + ['__doc__']:
-                symbol = getattr(symbol, name)
-            self.AutoCompCancel()
-            # Check that the symbol can indeed be converted to a string:
-            symbol += ''
-            wx.CallAfter(self.CallTipShow, self.GetCurrentPos(), symbol)
-        except:
-            # The retrieve symbol couldn't be converted to a string
-            pass
-
-
-    def _popup_completion(self, create=False):
-        """ Updates the popup completion menu if it exists. If create is
-            true, open the menu.
-        """
-        if self.debug:
-            print >>sys.__stdout__, "_popup_completion"
-        line = self.input_buffer
-        if (self.AutoCompActive() and line and not line[-1] == '.') \
-                    or create==True:
-            suggestion, completions = self.complete(line)
-            if completions:
-                offset = len(self._get_completion_text(line))
-                self.pop_completion(completions, offset=offset)
-                if self.debug:
-                    print >>sys.__stdout__, completions
-
-
-    def buffered_write(self, text):
-        """ A write method for streams, that caches the stream in order
-            to avoid flooding the event loop.
-
-            This can be called outside of the main loop, in separate
-            threads.
-        """
-        self._out_buffer_lock.acquire()
-        self._out_buffer.append(text)
-        self._out_buffer_lock.release()
-        if not self._buffer_flush_timer.IsRunning():
-            wx.CallAfter(self._buffer_flush_timer.Start,
-                                        milliseconds=100, oneShot=True)
-
-
-    def clear_screen(self):
-        """ Empty completely the widget.
-        """
-        self.ClearAll()
-        self.new_prompt(self.input_prompt_template.substitute(
-                                number=(self.last_result['number'] + 1)))
-
-
-    #--------------------------------------------------------------------------
-    # LineFrontEnd interface
-    #--------------------------------------------------------------------------
-
-    def execute(self, python_string, raw_string=None):
-        self._input_state = 'buffering'
-        self.CallTipCancel()
-        self._cursor = wx.BusyCursor()
-        if raw_string is None:
-            raw_string = python_string
-        end_line = self.current_prompt_line \
-                        + max(1,  len(raw_string.split('\n'))-1)
-        for i in range(self.current_prompt_line, end_line):
-            if i in self._markers:
-                self.MarkerDeleteHandle(self._markers[i])
-            self._markers[i] = self.MarkerAdd(i, _COMPLETE_BUFFER_MARKER)
-        # Use a callafter to update the display robustly under windows
-        def callback():
-            self.GotoPos(self.GetLength())
-            PrefilterFrontEnd.execute(self, python_string,
-                                            raw_string=raw_string)
-        wx.CallAfter(callback)
-
-
-    def execute_command(self, command, hidden=False):
-        """ Execute a command, not only in the model, but also in the
-            view.
-        """
-        # XXX: This method needs to be integrated in the base fronted
-        # interface
-        if hidden:
-            return self.shell.execute(command)
-        else:
-            # XXX: we are not storing the input buffer previous to the
-            # execution, as this forces us to run the execution
-            # input_buffer a yield, which is not good.
-            ##current_buffer = self.shell.control.input_buffer
-            command = command.rstrip()
-            if len(command.split('\n')) > 1:
-                # The input command is several lines long, we need to
-                # force the execution to happen
-                command += '\n'
-            cleaned_command = self.prefilter_input(command)
-            self.input_buffer = command
-            # Do not use wx.Yield() (aka GUI.process_events()) to avoid
-            # recursive yields.
-            self.ProcessEvent(wx.PaintEvent())
-            self.write('\n')
-            if not self.is_complete(cleaned_command + '\n'):
-                self._colorize_input_buffer()
-                self.render_error('Incomplete or invalid input')
-                self.new_prompt(self.input_prompt_template.substitute(
-                                number=(self.last_result['number'] + 1)))
-                return False
-            self._on_enter()
-            return True
-
-
-    def save_output_hooks(self):
-        self.__old_raw_input = __builtin__.raw_input
-        PrefilterFrontEnd.save_output_hooks(self)
-
-    def capture_output(self):
-        self.SetLexer(stc.STC_LEX_NULL)
-        PrefilterFrontEnd.capture_output(self)
-        __builtin__.raw_input = self.raw_input
-
-
-    def release_output(self):
-        __builtin__.raw_input = self.__old_raw_input
-        PrefilterFrontEnd.release_output(self)
-        self.SetLexer(stc.STC_LEX_PYTHON)
-
-
-    def after_execute(self):
-        PrefilterFrontEnd.after_execute(self)
-        # Clear the wait cursor
-        if hasattr(self, '_cursor'):
-            del self._cursor
-        self.SetCursor(wx.StockCursor(wx.CURSOR_CHAR))
-
-
-    def show_traceback(self):
-        start_line = self.GetCurrentLine()
-        PrefilterFrontEnd.show_traceback(self)
-        self.ProcessEvent(wx.PaintEvent())
-        #wx.Yield()
-        for i in range(start_line, self.GetCurrentLine()):
-            self._markers[i] = self.MarkerAdd(i, _ERROR_MARKER)
-
-
-    #--------------------------------------------------------------------------
-    # FrontEndBase interface
-    #--------------------------------------------------------------------------
-
-    def render_error(self, e):
-        start_line = self.GetCurrentLine()
-        self.write('\n' + e + '\n')
-        for i in range(start_line, self.GetCurrentLine()):
-            self._markers[i] = self.MarkerAdd(i, _ERROR_MARKER)
-
-
-    #--------------------------------------------------------------------------
-    # ConsoleWidget interface
-    #--------------------------------------------------------------------------
-
-    def new_prompt(self, prompt):
-        """ Display a new prompt, and start a new input buffer.
-        """
-        self._input_state = 'readline'
-        ConsoleWidget.new_prompt(self, prompt)
-        i = self.current_prompt_line
-        self._markers[i] = self.MarkerAdd(i, _INPUT_MARKER)
-
-
-    def continuation_prompt(self, *args, **kwargs):
-        # Avoid multiple inheritence, be explicit about which
-        # parent method class gets called
-        return ConsoleWidget.continuation_prompt(self, *args, **kwargs)
-
-
-    def write(self, *args, **kwargs):
-        # Avoid multiple inheritence, be explicit about which
-        # parent method class gets called
-        return ConsoleWidget.write(self, *args, **kwargs)
-
-
-    def _on_key_down(self, event, skip=True):
-        """ Capture the character events, let the parent
-            widget handle them, and put our logic afterward.
-        """
-        # FIXME: This method needs to be broken down in smaller ones.
-        current_line_num = self.GetCurrentLine()
-        key_code = event.GetKeyCode()
-        if key_code in (ord('c'), ord('C')) and event.ControlDown():
-            # Capture Control-C
-            if self._input_state == 'subprocess':
-                if self.debug:
-                    print >>sys.__stderr__, 'Killing running process'
-                if hasattr(self._running_process, 'process'):
-                    self._running_process.process.kill()
-            elif self._input_state == 'buffering':
-                if self.debug:
-                    print >>sys.__stderr__, 'Raising KeyboardInterrupt'
-                raise KeyboardInterrupt
-                # XXX: We need to make really sure we
-                # get back to a prompt.
-        elif self._input_state == 'subprocess' and (
-                ( key_code <256 and not event.ControlDown() )
-                    or
-                ( key_code in (ord('d'), ord('D')) and
-                  event.ControlDown())):
-            #  We are running a process, we redirect keys.
-            ConsoleWidget._on_key_down(self, event, skip=skip)
-            char = chr(key_code)
-            # Deal with some inconsistency in wx keycodes:
-            if char == '\r':
-                char = '\n'
-            elif not event.ShiftDown():
-                char = char.lower()
-            if event.ControlDown() and key_code in (ord('d'), ord('D')):
-                char = '\04'
-            self._running_process.process.stdin.write(char)
-            self._running_process.process.stdin.flush()
-        elif key_code in (ord('('), 57, 53):
-            # Calltips
-            event.Skip()
-            self.do_calltip()
-        elif self.AutoCompActive() and not key_code == ord('\t'):
-            event.Skip()
-            if key_code in (wx.WXK_BACK, wx.WXK_DELETE):
-                wx.CallAfter(self._popup_completion, create=True)
-            elif not key_code in (wx.WXK_UP, wx.WXK_DOWN, wx.WXK_LEFT,
-                            wx.WXK_RIGHT, wx.WXK_ESCAPE):
-                wx.CallAfter(self._popup_completion)
-        else:
-            # Up history
-            if key_code == wx.WXK_UP and (
-                            event.ControlDown() or
-                            current_line_num == self.current_prompt_line
-                    ):
-                new_buffer = self.get_history_previous(
-                                            self.input_buffer)
-                if new_buffer is not None:
-                    self.input_buffer = new_buffer
-                    if self.GetCurrentLine() > self.current_prompt_line:
-                        # Go to first line, for seemless history up.
-                        self.GotoPos(self.current_prompt_pos)
-            # Down history
-            elif key_code == wx.WXK_DOWN and (
-                            event.ControlDown() or
-                            current_line_num == self.LineCount -1
-                    ):
-                new_buffer = self.get_history_next()
-                if new_buffer is not None:
-                    self.input_buffer = new_buffer
-            # Tab-completion
-            elif key_code == ord('\t'):
-                current_line, current_line_num = self.CurLine
-                if not re.match(r'^%s\s*$' % self.continuation_prompt(),
-                                                            current_line):
-                    self.complete_current_input()
-                    if self.AutoCompActive():
-                        wx.CallAfter(self._popup_completion, create=True)
-                else:
-                    event.Skip()
-            elif key_code == wx.WXK_BACK:
-                # If characters where erased, check if we have to
-                # remove a line.
-                # XXX: What about DEL?
-                # FIXME: This logics should be in ConsoleWidget, as it is
-                # independant of IPython
-                current_line, _ = self.CurLine
-                current_pos = self.GetCurrentPos()
-                current_line_num = self.LineFromPosition(current_pos)
-                current_col = self.GetColumn(current_pos)
-                len_prompt = len(self.continuation_prompt())
-                if ( current_line.startswith(self.continuation_prompt())
-                                            and current_col == len_prompt):
-                    new_lines = []
-                    for line_num, line in enumerate(
-                                    self.input_buffer.split('\n')):
-                        if (line_num + self.current_prompt_line ==
-                                            current_line_num):
-                            new_lines.append(line[len_prompt:])
-                        else:
-                            new_lines.append('\n'+line)
-                    # The first character is '\n', due to the above
-                    # code:
-                    self.input_buffer = ''.join(new_lines)[1:]
-                    self.GotoPos(current_pos - 1 - len_prompt)
-                else:
-                    ConsoleWidget._on_key_down(self, event, skip=skip)
-            else:
-                ConsoleWidget._on_key_down(self, event, skip=skip)
-
-
-
-    def _on_key_up(self, event, skip=True):
-        """ Called when any key is released.
-        """
-        if event.GetKeyCode() in (59, ord('.')):
-            # Intercepting '.'
-            event.Skip()
-            wx.CallAfter(self._popup_completion, create=True)
-        else:
-            ConsoleWidget._on_key_up(self, event, skip=skip)
-        # Make sure the continuation_prompts are always followed by a
-        # whitespace
-        new_lines = []
-        if self._input_state == 'readline':
-            position = self.GetCurrentPos()
-            continuation_prompt = self.continuation_prompt()[:-1]
-            for line in self.input_buffer.split('\n'):
-                if not line == continuation_prompt:
-                    new_lines.append(line)
-            self.input_buffer = '\n'.join(new_lines)
-            self.GotoPos(position)
-
-
-    def _on_enter(self):
-        """ Called on return key down, in readline input_state.
-        """
-        last_line_num = self.LineFromPosition(self.GetLength())
-        current_line_num = self.LineFromPosition(self.GetCurrentPos())
-        new_line_pos = (last_line_num - current_line_num)
-        if self.debug:
-            print >>sys.__stdout__, repr(self.input_buffer)
-        self.write('\n', refresh=False)
-        # Under windows scintilla seems to be doing funny
-        # stuff to the line returns here, but the getter for
-        # input_buffer filters this out.
-        if sys.platform == 'win32':
-            self.input_buffer = self.input_buffer
-        old_prompt_num = self.current_prompt_pos
-        has_executed = PrefilterFrontEnd._on_enter(self,
-                                            new_line_pos=new_line_pos)
-        if old_prompt_num == self.current_prompt_pos:
-            # No execution has happened
-            self.GotoPos(self.GetLineEndPosition(current_line_num + 1))
-        return has_executed
-
-
-    #--------------------------------------------------------------------------
-    # EditWindow API
-    #--------------------------------------------------------------------------
-
-    def OnUpdateUI(self, event):
-        """ Override the OnUpdateUI of the EditWindow class, to prevent
-            syntax highlighting both for faster redraw, and for more
-            consistent look and feel.
-        """
-        if not self._input_state == 'readline':
-            ConsoleWidget.OnUpdateUI(self, event)
-
-    #--------------------------------------------------------------------------
-    # Private API
-    #--------------------------------------------------------------------------
-
-    def _buffer_flush(self, event):
-        """ Called by the timer to flush the write buffer.
-
-            This is always called in the mainloop, by the wx timer.
-        """
-        self._out_buffer_lock.acquire()
-        _out_buffer = self._out_buffer
-        self._out_buffer = []
-        self._out_buffer_lock.release()
-        self.write(''.join(_out_buffer), refresh=False)
-
-
-    def _colorize_input_buffer(self):
-        """ Keep the input buffer lines at a bright color.
-        """
-        if not self._input_state in ('readline', 'raw_input'):
-            return
-        end_line = self.GetCurrentLine()
-        if not sys.platform == 'win32':
-            end_line += 1
-        for i in range(self.current_prompt_line, end_line):
-            if i in self._markers:
-                self.MarkerDeleteHandle(self._markers[i])
-            self._markers[i] = self.MarkerAdd(i, _INPUT_MARKER)
-
-
-if __name__ == '__main__':
-    class MainWindow(wx.Frame):
-        def __init__(self, parent, id, title):
-            wx.Frame.__init__(self, parent, id, title, size=(300,250))
-            self._sizer = wx.BoxSizer(wx.VERTICAL)
-            self.shell = WxController(self)
-            self._sizer.Add(self.shell, 1, wx.EXPAND)
-            self.SetSizer(self._sizer)
-            self.SetAutoLayout(1)
-            self.Show(True)
-
-    app = wx.PySimpleApp()
-    frame = MainWindow(None, wx.ID_ANY, 'Ipython')
-    frame.shell.SetFocus()
-    frame.SetSize((680, 460))
-    self = frame.shell
-
-    app.MainLoop()
-

IPython/deathrow/oldfrontend/zopeinterface.py

@@ -1,27 +0,0 b''
-# encoding: utf-8
-# -*- test-case-name: IPython.frontend.tests.test_frontendbase -*-
-"""
-zope.interface mock. If zope is installed, this module provides a zope
-interface classes, if not it provides mocks for them.
-
-Classes provided:
-Interface, Attribute, implements, classProvides
-"""
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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.
-#-------------------------------------------------------------------------------
-
-try:
-    from zope.interface import Interface, Attribute, implements, classProvides
-except ImportError:
-    #zope.interface is not available
-    Interface = object
-    def Attribute(name, doc): pass
-    def implements(interface): pass
-    def classProvides(interface): pass
-

IPython/deathrow/outputtrap.py

@@ -1,258 +0,0 b''
-# -*- coding: utf-8 -*-
-"""Class to trap stdout and stderr and log them separately.
-"""
-
-#*****************************************************************************
-#       Copyright (C) 2001-2004 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.
-#*****************************************************************************
-
-import exceptions
-import sys
-from cStringIO import StringIO
-
-class OutputTrapError(exceptions.Exception):
-    """Exception for OutputTrap class."""
-
-    def __init__(self,args=None):
-        exceptions.Exception.__init__(self)
-        self.args = args
-
-class OutputTrap:
-
-    """Class to trap standard output and standard error. They get logged in
-    StringIO objects which are available as <instance>.out and
-    <instance>.err. The class also offers summary methods which format this
-    data a bit.
-
-    A word of caution: because it blocks messages, using this class can make
-    debugging very tricky. If you are having bizarre problems silently, try
-    turning your output traps off for a while. You can call the constructor
-    with the parameter debug=1 for these cases. This turns actual trapping
-    off, but you can keep the rest of your code unchanged (this has already
-    been a life saver).
-
-    Example:
-
-    # config: trapper with a line of dots as log separator (final '\\n' needed)
-    config = OutputTrap('Config','Out ','Err ','.'*80+'\\n')
-
-    # start trapping output
-    config.trap_all()
-
-    # now all output is logged ...
-    # do stuff...
-
-    # output back to normal:
-    config.release_all()
-
-    # print all that got logged:
-    print config.summary()
-
-    # print individual raw data:
-    print config.out.getvalue()
-    print config.err.getvalue()
-    """
-
-    def __init__(self,name='Generic Output Trap',
-                 out_head='Standard Output. ',err_head='Standard Error. ',
-                 sum_sep='\n',debug=0,trap_out=0,trap_err=0,
-                 quiet_out=0,quiet_err=0):
-        self.name = name
-        self.out_head = out_head
-        self.err_head = err_head
-        self.sum_sep = sum_sep
-        self.out = StringIO()
-        self.err = StringIO()
-        self.out_save = None
-        self.err_save = None
-        self.debug = debug
-        self.quiet_out = quiet_out
-        self.quiet_err = quiet_err
-        if trap_out:
-            self.trap_out()
-        if trap_err:
-            self.trap_err()
-
-    def trap_out(self):
-        """Trap and log stdout."""
-        if sys.stdout is self.out:
-            raise OutputTrapError,'You are already trapping stdout.'
-        if not self.debug:
-            self._out_save = sys.stdout
-            sys.stdout = self.out
-
-    def release_out(self):
-        """Release stdout."""
-        if not self.debug:
-            if not sys.stdout is self.out:
-                raise OutputTrapError,'You are not trapping stdout.'
-            sys.stdout = self._out_save
-            self.out_save = None
-
-    def summary_out(self):
-        """Return as a string the log from stdout."""
-        out = self.out.getvalue()
-        if out:
-            if self.quiet_out:
-                return out
-            else:
-                return self.out_head + 'Log by '+ self.name + ':\n' + out
-        else:
-            return ''
-
-    def flush_out(self):
-        """Flush the stdout log. All data held in the log is lost."""
-
-        self.out.close()
-        self.out = StringIO()
-
-    def trap_err(self):
-        """Trap and log stderr."""
-        if sys.stderr is self.err:
-            raise OutputTrapError,'You are already trapping stderr.'
-        if not self.debug:
-            self._err_save = sys.stderr
-            sys.stderr = self.err
-
-    def release_err(self):
-        """Release stderr."""
-        if not self.debug:
-            if not sys.stderr is self.err:
-                raise OutputTrapError,'You are not trapping stderr.'
-            sys.stderr = self._err_save
-            self.err_save = None
-
-    def summary_err(self):
-        """Return as a string the log from stderr."""
-        err = self.err.getvalue()
-        if err:
-            if self.quiet_err:
-                return err
-            else:
-                return self.err_head + 'Log by '+ self.name + ':\n' + err
-        else:
-            return ''
-
-    def flush_err(self):
-        """Flush the stdout log. All data held in the log is lost."""
-
-        self.err.close()
-        self.err = StringIO()
-
-    def trap_all(self):
-        """Trap and log both stdout and stderr.
-
-        Cacthes and discards OutputTrapError exceptions raised."""
-        try:
-            self.trap_out()
-        except OutputTrapError:
-            pass
-        try:
-            self.trap_err()
-        except OutputTrapError:
-            pass
-
-    def release_all(self):
-        """Release both stdout and stderr.
-
-        Cacthes and discards OutputTrapError exceptions raised."""
-        try:
-            self.release_out()
-        except OutputTrapError:
-            pass
-        try:
-            self.release_err()
-        except OutputTrapError:
-            pass
-        
-    def summary_all(self):
-        """Return as a string the log from stdout and stderr, prepending a separator
-        to each (defined in __init__ as sum_sep)."""
-        sum = ''
-        sout = self.summary_out()
-        if sout:
-            sum += self.sum_sep + sout
-        serr = self.summary_err()
-        if serr:
-            sum += '\n'+self.sum_sep + serr
-        return sum
-
-    def flush_all(self):
-        """Flush stdout and stderr"""
-        self.flush_out()
-        self.flush_err()
-
-    # a few shorthands
-    trap = trap_all
-    release = release_all
-    summary = summary_all
-    flush = flush_all
-# end OutputTrap
-
-
-#****************************************************************************
-# Module testing. Incomplete, I'm lazy...
-
-def _test_all():
-
-    """Module testing functions, activated when the module is called as a
-    script (not imported)."""
-
-    # Put tests for this module in here.
-    # Define them as nested functions so they don't clobber the
-    # pydoc-generated docs
-
-    def _test_():
-        name = ''
-        print '#'*50+'\nRunning test for ' + name
-        # ...
-        print 'Finished test for '+ name +'\n'+'#'*50
-
-    def _test_OutputTrap():
-        trap = OutputTrap(name = 'Test Trap', sum_sep = '.'*50+'\n',
-                          out_head = 'SOut. ', err_head = 'SErr. ')
-
-        name = 'OutputTrap class'
-        print '#'*50+'\nRunning test for ' + name
-        print 'Trapping out'
-        trap.trap_out()
-        print >>sys.stdout, '>>stdout. stdout is trapped.'
-        print >>sys.stderr, '>>stderr. stdout is trapped.'
-        trap.release_out()
-        print trap.summary_out()
-
-        print 'Trapping err'
-        trap.trap_err()
-        print >>sys.stdout, '>>stdout. stderr is trapped.'
-        print >>sys.stderr, '>>stderr. stderr is trapped.'
-        trap.release_err()
-        print trap.summary_err()
-
-        print 'Trapping all (no flushing)'
-        trap.trap_all()
-        print >>sys.stdout, '>>stdout. stdout/err is trapped.'
-        print >>sys.stderr, '>>stderr. stdout/err is trapped.'
-        trap.release_all()
-        print trap.summary_all()
-
-        print 'Trapping all (flushing first)'
-        trap.flush()
-        trap.trap_all()
-        print >>sys.stdout, '>>stdout. stdout/err is trapped.'
-        print >>sys.stderr, '>>stderr. stdout/err is trapped.'
-        trap.release_all()
-        print trap.summary_all()
-        print 'Finished test for '+ name +'\n'+'#'*50
-
-    # call the actual tests here:
-    _test_OutputTrap()
-
-
-if __name__=="__main__":
-    # _test_all() # XXX BROKEN.
-    pass
-
-#************************ end of file <OutputTrap.py> ************************

IPython/deathrow/quitter.py

@@ -1,47 +0,0 b''
-# coding: utf-8
-"""
-A simple class for quitting IPython.
-
-Authors
--------
-* Fernando Perez
-* Brian Granger
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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
-#-----------------------------------------------------------------------------
-
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-
-class Quitter(object):
-    """Simple class to handle exit, similar to Python 2.5's.
-
-    It handles exiting in an ipython-safe manner, which the one in Python 2.5
-    doesn't do (obviously, since it doesn't know about ipython)."""
-    
-    def __init__(self, shell, name):
-        self.shell = shell
-        self.name = name
-        
-    def __str__(self):
-        return 'Type %s() to exit.' % self.name
-
-    def __call__(self):
-        self.shell.ask_exit()
-
-    # Repr MUST return a string, else display like pprint hooks get confused
-    def __repr__(self):
-        self.shell.ask_exit()
-        return ''

IPython/deathrow/scitedirector.py

@@ -1,26 +0,0 b''
-import win32api
-import win32gui
-import win32con
-
-import struct
-import array
-
-def findWindows():
-    ret = []
-    sdi = win32api.RegisterWindowMessage("SciTEDirectorInterface")
-    w = win32gui.GetWindow(win32gui.GetDesktopWindow(), win32con.GW_CHILD)
-    while w:
-        res = win32gui.SendMessage(w, sdi, 0, 0)
-        if res == sdi:
-            ret.append(w)
-        w = win32gui.GetWindow(w, win32con.GW_HWNDNEXT)
-
-    return ret
-
-def sendCommand(w, message):
-    CopyDataStruct = "IIP"
-    char_buffer = array.array('c', message)
-    char_buffer_address = char_buffer.buffer_info()[0]
-    char_buffer_size = char_buffer.buffer_info()[1]
-    cds = struct.pack(CopyDataStruct, 0, char_buffer_size, char_buffer_address)
-    win32gui.SendMessage(w, win32con.WM_COPYDATA, 0, cds)

IPython/deathrow/tests/test_prefilter.py

@@ -1,440 +0,0 b''
-"""
-Test which prefilter transformations get called for various input lines.
-Note that this does *not* test the transformations themselves -- it's just
-verifying that a particular combination of, e.g. config options and escape
-chars trigger the proper handle_X transform of the input line.
-
-Usage: run from the command line with *normal* python, not ipython:
-> python test_prefilter.py
-
-Fairly quiet output by default.  Pass in -v to get everyone's favorite dots.
-"""
-
-# The prefilter always ends in a call to some self.handle_X method.  We swap
-# all of those out so that we can capture which one was called.
-
-import sys
-sys.path.append('..')
-import IPython
-import IPython.ipapi
-
-verbose = False
-if len(sys.argv) > 1:
-    if sys.argv[1] == '-v':
-        sys.argv = sys.argv[:-1]  # IPython is confused by -v, apparently
-        verbose = True
-
-IPython.Shell.start()
-
-ip = IPython.ipapi.get()
-
-# Collect failed tests + stats and print them at the end
-failures = []
-num_tests = 0
-
-# Store the results in module vars as we go
-last_line      = None
-handler_called = None
-def install_mock_handler(name):
-    """Swap out one of the IP.handle_x methods with a function which can
-    record which handler was called and what line was produced. The mock
-    handler func always returns '', which causes ipython to cease handling
-    the string immediately.  That way, that it doesn't echo output, raise
-    exceptions, etc.  But do note that testing multiline strings thus gets
-    a bit hard."""
-    def mock_handler(self, line, continue_prompt=None,
-                     pre=None,iFun=None,theRest=None,
-                     obj=None):
-        #print "Inside %s with '%s'" % (name, line)
-        global last_line, handler_called
-        last_line = line
-        handler_called = name
-        return ''
-    mock_handler.name = name
-    setattr(IPython.iplib.InteractiveShell, name, mock_handler)
-
-install_mock_handler('handle_normal')
-install_mock_handler('handle_auto')
-install_mock_handler('handle_magic')
-install_mock_handler('handle_help')
-install_mock_handler('handle_shell_escape')
-install_mock_handler('handle_alias')
-install_mock_handler('handle_emacs')
-
-
-def reset_esc_handlers():
-    """The escape handlers are stored in a hash (as an attribute of the
-    InteractiveShell *instance*), so we have to rebuild that hash to get our
-    new handlers in there."""
-    s = ip.IP
-    s.esc_handlers = {s.ESC_PAREN  : s.handle_auto,
-                      s.ESC_QUOTE  : s.handle_auto,
-                      s.ESC_QUOTE2 : s.handle_auto,
-                      s.ESC_MAGIC  : s.handle_magic,
-                      s.ESC_HELP   : s.handle_help,
-                      s.ESC_SHELL  : s.handle_shell_escape,
-                      s.ESC_SH_CAP : s.handle_shell_escape,
-                      }
-reset_esc_handlers()
-
-# This is so I don't have to quote over and over.  Gotta be a better way.
-handle_normal       = 'handle_normal'
-handle_auto         = 'handle_auto'
-handle_magic        = 'handle_magic'
-handle_help         = 'handle_help'
-handle_shell_escape = 'handle_shell_escape'
-handle_alias        = 'handle_alias'
-handle_emacs        = 'handle_emacs'
-
-def check(assertion, failure_msg):
-    """Check a boolean assertion and fail with a message if necessary. Store
-    an error essage in module-level failures list in case of failure.  Print
-    '.' or 'F' if module var Verbose is true.
-    """
-    global num_tests
-    num_tests += 1
-    if assertion:
-        if verbose:
-            sys.stdout.write('.')
-            sys.stdout.flush()
-    else:
-        if verbose:
-            sys.stdout.write('F')
-            sys.stdout.flush()
-        failures.append(failure_msg)
-
-
-def check_handler(expected_handler, line):
-    """Verify that the expected hander was called (for the given line,
-    passed in for failure reporting).
-
-    Pulled out to its own function so that tests which don't use
-    run_handler_tests can still take advantage of it."""
-    check(handler_called == expected_handler,
-          "Expected %s to be called for %s, "
-          "instead %s called" % (expected_handler,
-                                 repr(line),
-                                 handler_called))
-
-
-def run_handler_tests(h_tests):
-    """Loop through a series of (input_line, handler_name) pairs, verifying
-    that, for each ip calls the given handler for the given line.
-
-    The verbose complaint includes the line passed in, so if that line can
-    include enough info to find the error, the tests are modestly
-    self-documenting.
-    """
-    for ln, expected_handler in h_tests:
-        global handler_called
-        handler_called = None
-        ip.runlines(ln)
-        check_handler(expected_handler, ln)
-
-def run_one_test(ln, expected_handler):
-    run_handler_tests([(ln, expected_handler)])
-
-
-# =========================================
-# Tests
-# =========================================
-
-
-# Fundamental escape characters + whitespace & misc
-# =================================================
-esc_handler_tests = [
-    ( '?thing',    handle_help,  ),
-    ( 'thing?',    handle_help ),  # '?' can trail...
-    ( 'thing!',    handle_normal), # but only '?' can trail
-    ( '   ?thing', handle_normal), # leading whitespace turns off esc chars
-    ( '!ls',       handle_shell_escape),
-    ( '! true',    handle_shell_escape),
-    ( '!! true',   handle_shell_escape),
-    ( '%magic',    handle_magic),
-    # XXX Possibly, add test for /,; once those are unhooked from %autocall
-    ( 'emacs_mode # PYTHON-MODE', handle_emacs ),
-    ( ' ',         handle_normal),
-
-    # Trailing qmark combos.  Odd special cases abound
-
-    # ! always takes priority!
-    ( '!thing?',      handle_shell_escape),
-    ( '!thing arg?',  handle_shell_escape),
-    ( '!!thing?',     handle_shell_escape),
-    ( '!!thing arg?', handle_shell_escape),
-    ( '    !!thing arg?', handle_shell_escape),
-
-    # For all other leading esc chars, we always trigger help
-    ( '%cmd?',     handle_help),
-    ( '%cmd ?',    handle_help),
-    ( '/cmd?',     handle_help),
-    ( '/cmd ?',    handle_help),
-    ( ';cmd?',     handle_help),
-    ( ',cmd?',     handle_help),
-    ]
-run_handler_tests(esc_handler_tests)
-
-
-
-# Shell Escapes in Multi-line statements
-# ======================================
-#
-# We can't test this via runlines, since the hacked-over-for-testing
-# handlers all return None, so continue_prompt never becomes true.  Instead
-# we drop into prefilter directly and pass in continue_prompt.
-
-old_mls = ip.options.multi_line_specials
-for ln in [ '    !ls $f multi_line_specials %s',
-            '    !!ls $f multi_line_specials %s',  # !! escapes work on mls
-            # Trailing ? doesn't trigger help:
-            '    !ls $f multi_line_specials %s ?',
-            '    !!ls $f multi_line_specials %s ?',
-            ]:
-    ip.options.multi_line_specials = 1
-    on_ln = ln % 'on'
-    ignore = ip.IP.prefilter(on_ln, continue_prompt=True)
-    check_handler(handle_shell_escape, on_ln)
-
-    ip.options.multi_line_specials = 0
-    off_ln = ln % 'off'
-    ignore = ip.IP.prefilter(off_ln, continue_prompt=True)
-    check_handler(handle_normal, off_ln)
-
-ip.options.multi_line_specials = old_mls
-
-
-# Automagic
-# =========
-
-# Pick one magic fun and one non_magic fun, make sure both exist
-assert hasattr(ip.IP, "magic_cpaste")
-assert not hasattr(ip.IP, "magic_does_not_exist")
-ip.options.autocall = 0 # gotta have this off to get handle_normal
-ip.options.automagic = 0
-run_handler_tests([
-    # Without automagic, only shows up with explicit escape
-    ( 'cpaste', handle_normal),
-    ( '%cpaste', handle_magic),
-    ( '%does_not_exist', handle_magic),
-    ])
-ip.options.automagic = 1
-run_handler_tests([
-    ( 'cpaste',          handle_magic),
-    ( '%cpaste',         handle_magic),
-    ( 'does_not_exist',  handle_normal),
-    ( '%does_not_exist', handle_magic),
-    ( 'cd /',            handle_magic),
-    ( 'cd = 2',          handle_normal),
-    ( 'r',               handle_magic),
-    ( 'r thing',         handle_magic),
-    ( 'r"str"',          handle_normal),
-    ])
-
-# If next elt starts with anything that could be an assignment, func call,
-# etc, we don't call the magic func, unless explicitly escaped to do so.
-#magic_killing_tests = []
-#for c in list('!=()<>,'):
-#    magic_killing_tests.append(('cpaste %s killed_automagic' % c, handle_normal))
-#    magic_killing_tests.append(('%%cpaste %s escaped_magic' % c,   handle_magic))
-#run_handler_tests(magic_killing_tests)
-
-# magic on indented continuation lines -- on iff multi_line_specials == 1
-ip.options.multi_line_specials = 0
-ln = '    cpaste multi_line off kills magic'
-ignore = ip.IP.prefilter(ln, continue_prompt=True)
-check_handler(handle_normal, ln)
-
-ip.options.multi_line_specials = 1
-ln = '    cpaste multi_line on enables magic'
-ignore = ip.IP.prefilter(ln, continue_prompt=True)
-check_handler(handle_magic, ln)
-
-# user namespace shadows the magic one unless shell escaped
-ip.user_ns['cpaste']     = 'user_ns'
-run_handler_tests([
-    ( 'cpaste',    handle_normal),
-    ( '%cpaste',   handle_magic)])
-del ip.user_ns['cpaste']
-
-
-
-# Check for !=() turning off .ofind
-# =================================
-class AttributeMutator(object):
-    """A class which will be modified on attribute access, to test ofind"""
-    def __init__(self):
-        self.called = False
-
-    def getFoo(self): self.called = True
-    foo = property(getFoo)
-
-attr_mutator = AttributeMutator()
-ip.to_user_ns('attr_mutator')
-
-ip.options.autocall = 1
-
-run_one_test('attr_mutator.foo should mutate', handle_normal)
-check(attr_mutator.called, 'ofind should be called in absence of assign characters')
-
-for c in list('!=()<>+*/%^&|'):
-    attr_mutator.called = False
-    run_one_test('attr_mutator.foo %s should *not* mutate' % c, handle_normal)
-    run_one_test('attr_mutator.foo%s should *not* mutate' % c, handle_normal)
-
-    check(not attr_mutator.called,
-          'ofind should not be called near character %s' % c)
-
-
-
-# Alias expansion
-# ===============
-
-# With autocall on or off, aliases should be shadowed by user, internal and
-# __builtin__ namespaces
-#
-# XXX Can aliases have '.' in their name?  With autocall off, that works,
-# with autocall on, it doesn't.  Hmmm.
-import __builtin__
-for ac_state in [0,1]:
-    ip.options.autocall = ac_state
-    ip.IP.alias_table['alias_cmd'] = 'alias_result'
-    ip.IP.alias_table['alias_head.with_dot'] = 'alias_result'
-    run_handler_tests([
-        ("alias_cmd",           handle_alias),
-        # XXX See note above
-        #("alias_head.with_dot unshadowed, autocall=%s" % ac_state, handle_alias),
-        ("alias_cmd.something aliases must match whole expr", handle_normal),
-        ("alias_cmd /", handle_alias),
-        ])
-
-    for ns in [ip.user_ns, ip.IP.internal_ns, __builtin__.__dict__ ]:
-        ns['alias_cmd'] = 'a user value'
-        ns['alias_head'] = 'a user value'
-        run_handler_tests([
-            ("alias_cmd",           handle_normal),
-            ("alias_head.with_dot", handle_normal)])
-        del ns['alias_cmd']
-        del ns['alias_head']
-
-ip.options.autocall = 1
-
-
-
-
-# Autocall
-# ========
-
-# For all the tests below, 'len' is callable / 'thing' is not
-
-# Objects which are instances of IPyAutocall are *always* autocalled
-import IPython.ipapi
-class Autocallable(IPython.ipapi.IPyAutocall):
-    def __call__(self):
-        return "called"
-
-autocallable = Autocallable()
-ip.to_user_ns('autocallable')
-
-
-# First, with autocalling fully off
-ip.options.autocall = 0
-run_handler_tests( [
-    # With no escapes, no autocalling expansions happen, callable or not,
-    # unless the obj extends IPyAutocall
-    ( 'len autocall_0',     handle_normal),
-    ( 'thing autocall_0',   handle_normal),
-    ( 'autocallable',       handle_auto),
-
-    # With explicit escapes, callable and non-callables both get expanded,
-    # regardless of the %autocall setting:
-    ( '/len autocall_0',    handle_auto),
-    ( ',len autocall_0 b0', handle_auto),
-    ( ';len autocall_0 b0', handle_auto),
-
-    ( '/thing autocall_0',    handle_auto),
-    ( ',thing autocall_0 b0', handle_auto),
-    ( ';thing autocall_0 b0', handle_auto),
-
-    # Explicit autocall should not trigger if there is leading whitespace
-    ( ' /len autocall_0',    handle_normal),
-    ( ' ;len autocall_0',    handle_normal),
-    ( ' ,len autocall_0',    handle_normal),
-    ( ' / len autocall_0',   handle_normal),
-
-    # But should work if the whitespace comes after the esc char
-    ( '/ len autocall_0',    handle_auto),
-    ( '; len autocall_0',    handle_auto),
-    ( ', len autocall_0',    handle_auto),
-    ( '/  len autocall_0',   handle_auto),
-    ])
-
-
-# Now, with autocall in default, 'smart' mode
-ip.options.autocall = 1
-run_handler_tests( [
-    # Autocalls without escapes -- only expand if it's callable
-    ( 'len a1',       handle_auto),
-    ( 'thing a1',     handle_normal),
-    ( 'autocallable', handle_auto),
-
-    # As above, all explicit escapes generate auto-calls, callable or not
-    ( '/len a1',      handle_auto),
-    ( ',len a1 b1',   handle_auto),
-    ( ';len a1 b1',   handle_auto),
-    ( '/thing a1',    handle_auto),
-    ( ',thing a1 b1', handle_auto),
-    ( ';thing a1 b1', handle_auto),
-
-    # Autocalls only happen on things which look like funcs, even if
-    # explicitly requested. Which, in this case means they look like a
-    # sequence of identifiers and . attribute references. Possibly the
-    # second of these two should trigger handle_auto.  But not for now.
-    ( '"abc".join range(4)',   handle_normal),
-    ( '/"abc".join range(4)',  handle_normal),
-    ])
-
-
-# No tests for autocall = 2, since the extra magic there happens inside the
-# handle_auto function, which our test doesn't examine.
-
-# Note that we leave autocall in default, 1, 'smart' mode
-
-
-# Autocall / Binary operators
-# ==========================
-
-# Even with autocall on, 'len in thing' won't transform.
-# But ';len in thing' will
-
-# Note, the tests below don't check for multi-char ops. It could.
-
-# XXX % is a binary op and should be in the list, too, but fails
-bin_ops = list(r'<>,&^|*/+-') + 'is not in and or'.split()
-bin_tests = []
-for b in bin_ops:
-    bin_tests.append(('len %s binop_autocall'  % b, handle_normal))
-    bin_tests.append((';len %s binop_autocall' % b, handle_auto))
-    bin_tests.append((',len %s binop_autocall' % b, handle_auto))
-    bin_tests.append(('/len %s binop_autocall' % b, handle_auto))
-
-# Who loves auto-generating tests?
-run_handler_tests(bin_tests)
-
-
-# Possibly add tests for namespace shadowing (really ofind's business?).
-#
-# user > ipython internal > python builtin > alias > magic
-
-
-# ============
-# Test Summary
-# ============
-num_f = len(failures)
-if verbose:
-    print
-print "%s tests run, %s failure%s" % (num_tests,
-                                      num_f,
-                                      num_f != 1 and "s" or "")
-for f in failures:
-    print f
-

IPython/deathrow/twshell.py

@@ -1,287 +0,0 b''
-"""Twisted shell support.
-
-XXX - This module is missing proper docs.
-"""
-# Tell nose to skip this module
-__test__ = {}
-
-import sys
-
-from twisted.internet import reactor, threads
-
-from IPython.core.ipmaker import make_IPython
-from IPython.core.iplib import InteractiveShell
-from IPython.utils.ipstruct import Struct
-import Queue,thread,threading,signal
-from signal import signal, SIGINT
-import IPython.utils.io, ask_yes_no
-from IPython.utils.warn import warn, error
-from IPython.utils.decorators import flag_calls
-from IPython.core import shellglobals
-
-def install_gtk2():
-    """ Install gtk2 reactor, needs to be called bef """
-    from twisted.internet import gtk2reactor
-    gtk2reactor.install()
-
-
-def hijack_reactor():
-    """Modifies Twisted's reactor with a dummy so user code does
-    not block IPython.  This function returns the original
-    'twisted.internet.reactor' that has been hijacked.
-
-    NOTE: Make sure you call this *AFTER* you've installed
-    the reactor of your choice.
-    """
-    from twisted import internet
-    orig_reactor = internet.reactor
-
-    class DummyReactor(object):
-        def run(self):
-            pass
-        def __getattr__(self, name):
-            return getattr(orig_reactor, name)
-        def __setattr__(self, name, value):
-            return setattr(orig_reactor, name, value)
-
-    internet.reactor = DummyReactor()
-    return orig_reactor
-
-class TwistedInteractiveShell(InteractiveShell):
-    """Simple multi-threaded shell."""
-
-    # Threading strategy taken from:
-    # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
-    # McErlean and John Finlay.  Modified with corrections by Antoon Pardon,
-    # from the pygtk mailing list, to avoid lockups with system calls.
-
-    # class attribute to indicate whether the class supports threads or not.
-    # Subclasses with thread support should override this as needed.
-    isthreaded = True
-
-    def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
-                 user_ns=None,user_global_ns=None,banner2='',**kw):
-        """Similar to the normal InteractiveShell, but with threading control"""
-
-        InteractiveShell.__init__(self,name,usage,rc,user_ns,
-                                  user_global_ns,banner2)
-
-
-        # A queue to hold the code to be executed.
-        self.code_queue = Queue.Queue()
-
-        # Stuff to do at closing time
-        self._kill = None
-        on_kill = kw.get('on_kill', [])
-        # Check that all things to kill are callable:
-        for t in on_kill:
-            if not callable(t):
-                raise TypeError,'on_kill must be a list of callables'
-        self.on_kill = on_kill
-        # thread identity of the "worker thread" (that may execute code directly)
-        self.worker_ident = None
-        self.reactor_started = False
-        self.first_run = True
-
-    def runsource(self, source, filename="<input>", symbol="single"):
-        """Compile and run some source in the interpreter.
-
-        Modified version of code.py's runsource(), to handle threading issues.
-        See the original for full docstring details."""
-
-        # If Ctrl-C was typed, we reset the flag and return right away
-        if shellglobals.KBINT:
-            shellglobals.KBINT = False
-            return False
-
-        if self._kill:
-            # can't queue new code if we are being killed
-            return True
-
-        try:
-            code = self.compile(source, filename, symbol)
-        except (OverflowError, SyntaxError, ValueError):
-            # Case 1
-            self.showsyntaxerror(filename)
-            return False
-
-        if code is None:
-            # Case 2
-            return True
-
-        # shortcut - if we are in worker thread, or the worker thread is not running,
-        # execute directly (to allow recursion and prevent deadlock if code is run early
-        # in IPython construction)
-
-        if (not self.reactor_started or (self.worker_ident is None and not self.first_run)
-            or self.worker_ident == thread.get_ident() or shellglobals.run_in_frontend(source)):
-            InteractiveShell.runcode(self,code)
-            return
-
-        # Case 3
-        # Store code in queue, so the execution thread can handle it.
-
-        self.first_run = False
-        completed_ev, received_ev = threading.Event(), threading.Event()
-
-        self.code_queue.put((code,completed_ev, received_ev))
-
-        reactor.callLater(0.0,self.runcode)
-        received_ev.wait(5)
-        if not received_ev.isSet():
-            # the mainloop is dead, start executing code directly
-            print "Warning: Timeout for mainloop thread exceeded"
-            print "switching to nonthreaded mode (until mainloop wakes up again)"
-            self.worker_ident = None
-        else:
-            completed_ev.wait()
-
-        return False
-
-    def runcode(self):
-        """Execute a code object.
-
-        Multithreaded wrapper around IPython's runcode()."""
-
-
-        # we are in worker thread, stash out the id for runsource()
-        self.worker_ident = thread.get_ident()
-
-        if self._kill:
-            print >>Term.cout, 'Closing threads...',
-            Term.cout.flush()
-            for tokill in self.on_kill:
-                tokill()
-            print >>Term.cout, 'Done.'
-            # allow kill() to return
-            self._kill.set()
-            return True
-
-        # Install SIGINT handler.  We do it every time to ensure that if user
-        # code modifies it, we restore our own handling.
-        try:
-            pass
-            signal(SIGINT,shellglobals.sigint_handler)
-        except SystemError:
-            # This happens under Windows, which seems to have all sorts
-            # of problems with signal handling.  Oh well...
-            pass
-
-        # Flush queue of pending code by calling the run methood of the parent
-        # class with all items which may be in the queue.
-        code_to_run = None
-        while 1:
-            try:
-                code_to_run, completed_ev, received_ev = self.code_queue.get_nowait()
-            except Queue.Empty:
-                break
-            received_ev.set()
-
-
-            # Exceptions need to be raised differently depending on which
-            # thread is active.  This convoluted try/except is only there to
-            # protect against asynchronous exceptions, to ensure that a shellglobals.KBINT
-            # at the wrong time doesn't deadlock everything.  The global
-            # CODE_TO_RUN is set to true/false as close as possible to the
-            # runcode() call, so that the KBINT handler is correctly informed.
-            try:
-                try:
-                   shellglobals.CODE_RUN = True
-                   InteractiveShell.runcode(self,code_to_run)
-                except KeyboardInterrupt:
-                   print "Keyboard interrupted in mainloop"
-                   while not self.code_queue.empty():
-                      code = self.code_queue.get_nowait()
-                   break
-            finally:
-                shellglobals.CODE_RUN = False
-                # allow runsource() return from wait
-                completed_ev.set()
-
-        # This MUST return true for gtk threading to work
-        return True
-
-    def kill(self):
-        """Kill the thread, returning when it has been shut down."""
-        self._kill = threading.Event()
-        reactor.callLater(0.0,self.runcode)
-        self._kill.wait()
-
-
-
-class IPShellTwisted:
-    """Run a Twisted reactor while in an IPython session.
-
-    Python commands can be passed to the thread where they will be
-    executed.  This is implemented by periodically checking for
-    passed code using a Twisted reactor callback.
-    """
-
-    TIMEOUT = 0.01 # Millisecond interval between reactor runs.
-
-    def __init__(self, argv=None, user_ns=None, debug=1,
-                 shell_class=TwistedInteractiveShell):
-
-        from twisted.internet import reactor
-        self.reactor = hijack_reactor()
-
-        mainquit = self.reactor.stop
-
-        # Make sure IPython keeps going after reactor stop.
-        def reactorstop():
-            pass
-        self.reactor.stop = reactorstop
-        reactorrun_orig = self.reactor.run
-        self.quitting = False
-        def reactorrun():
-            while True and not self.quitting:
-                reactorrun_orig()
-        self.reactor.run = reactorrun
-
-        self.IP = make_IPython(argv, user_ns=user_ns, debug=debug,
-                               shell_class=shell_class,
-                               on_kill=[mainquit])
-
-        # threading.Thread.__init__(self)
-
-    def run(self):
-        self.IP.mainloop()
-        self.quitting = True
-        self.IP.kill()
-
-    def mainloop(self):
-        def mainLoopThreadDeath(r):
-            print "mainLoopThreadDeath: ", str(r)
-        def spawnMainloopThread():
-            d=threads.deferToThread(self.run)
-            d.addBoth(mainLoopThreadDeath)
-        reactor.callWhenRunning(spawnMainloopThread)
-        self.IP.reactor_started = True
-        self.reactor.run()
-        print "mainloop ending...."
-
-exists = True
-
-
-if __name__ == '__main__':
-    # Sample usage.
-
-    # Create the shell object. This steals twisted.internet.reactor
-    # for its own purposes, to make sure you've already installed a
-    # reactor of your choice.
-    shell = IPShellTwisted(
-        argv=[],
-        user_ns={'__name__': '__example__',
-                 'hello': 'world',
-                 },
-        )
-
-    # Run the mainloop.  This runs the actual reactor.run() method.
-    # The twisted.internet.reactor object at this point is a dummy
-    # object that passes through to the actual reactor, but prevents
-    # run() from being called on it again.
-    shell.mainloop()
-
-    # You must exit IPython to terminate your program.
-    print 'Goodbye!'
-

IPython/frontend/html/notebook/static/components

@@ -1,1 +0,0 b''
-Subproject commit 2a98f498092682f11affe9b0b86bd7e642cf7b13