"""Copied from code.py, to remove the dependency"""

oldvalue = 0

try:

oldvalue = file.softspace

except AttributeError:

pass

try:

file.softspace = newvalue

except (AttributeError, TypeError):

# "attribute-less object" or "read-only attributes"

pass

if sys.platform=='darwin':

return "LightBG"

elif os.name=='nt':

return 'Linux'

else:

r"""A Unicode subclass to validate separate_in, separate_out, etc.

def validate(self, obj, value):

if value == '0': value = ''

value = value.replace('\\n','\n')

"""Context manager to execute some code, then reload readline history

def __init__(self, shell):

self.shell = shell

self._nested_level = 0

def __enter__(self):

if self._nested_level == 0:

try:

self.orig_length = self.current_length()

self.readline_tail = self.get_readline_tail()

except (AttributeError, IndexError): # Can fail with pyreadline

self.orig_length, self.readline_tail = 999999, []

self._nested_level += 1

def __exit__(self, type, value, traceback):

self._nested_level -= 1

if self._nested_level == 0:

# Try clipping the end if it's got longer

try:

e = self.current_length() - self.orig_length

if e > 0:

for _ in range(e):

self.shell.readline.remove_history_item(self.orig_length)

# If it still doesn't match, just reload readline history.

if self.current_length() != self.orig_length \

or self.get_readline_tail() != self.readline_tail:

self.shell.refill_readline_hist()

except (AttributeError, IndexError):

pass

# Returning False will cause exceptions to propagate

return False

def current_length(self):

return self.shell.readline.get_current_history_length()

def get_readline_tail(self, n=10):

"""Get the last n items in readline history."""

end = self.shell.readline.get_current_history_length() + 1

start = max(end-n, 1)

ghi = self.shell.readline.get_history_item

"""An enhanced, interactive shell for Python."""

_instance = None

ast_transformers = List([], config=True, help=

"""

)

autocall = Enum((0,1,2), default_value=0, config=True, help=

"""

)

# TODO: remove all autoindent logic and put into frontends.

# We can't do this yet because even runlines uses the autoindent.

autoindent = CBool(True, config=True, help=

"""

)

automagic = CBool(True, config=True, help=

"""

)

cache_size = Integer(1000, config=True, help=

"""

)

color_info = CBool(True, config=True, help=

"""

)

colors = CaselessStrEnum(('NoColor','LightBG','Linux'),

default_value=get_default_colors(), config=True,

help="Set the color scheme (NoColor, Linux, or LightBG)."

)

colors_force = CBool(False, help=

"""

# FIXME: This is essentially a hack to allow ZMQShell to show colors

# without readline on Win32. When the ZMQ formatting system is

# refactored, this should be removed.

)

debug = CBool(False, config=True)

deep_reload = CBool(False, config=True, help=

"""

)

disable_failing_post_execute = CBool(False, config=True,

help="Don't call post-execute functions that have failed in the past."

)

display_formatter = Instance(DisplayFormatter)

displayhook_class = Type(DisplayHook)

display_pub_class = Type(DisplayPublisher)

data_pub_class = None

exit_now = CBool(False)

exiter = Instance(ExitAutocall)

def _exiter_default(self):

return ExitAutocall(self)

# Monotonically increasing execution counter

execution_count = Integer(1)

filename = Unicode("<ipython console>")

ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__

# Input splitter, to transform input line by line and detect when a block

# is ready to be executed.

input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',

(), {'line_input_checker': True})

# This InputSplitter instance is used to transform completed cells before

# running them. It allows cell magics to contain blank lines.

input_transformer_manager = Instance('IPython.core.inputsplitter.IPythonInputSplitter',

(), {'line_input_checker': False})

logstart = CBool(False, config=True, help=

"""

)

logfile = Unicode('', config=True, help=

"""

)

logappend = Unicode('', config=True, help=

"""

)

object_info_string_level = Enum((0,1,2), default_value=0,

config=True)

pdb = CBool(False, config=True, help=

"""

)

multiline_history = CBool(sys.platform != 'win32', config=True,

help="Save multi-line entries as one entry in readline history"

)

# deprecated prompt traits:

prompt_in1 = Unicode('In [\\#]: ', config=True,

help="Deprecated, use PromptManager.in_template")

prompt_in2 = Unicode(' .\\D.: ', config=True,

help="Deprecated, use PromptManager.in2_template")

prompt_out = Unicode('Out[\\#]: ', config=True,

help="Deprecated, use PromptManager.out_template")

prompts_pad_left = CBool(True, config=True,

help="Deprecated, use PromptManager.justify")

def _prompt_trait_changed(self, name, old, new):

table = {

'prompt_in1' : 'in_template',

'prompt_in2' : 'in2_template',

'prompt_out' : 'out_template',

'prompts_pad_left' : 'justify',

}

warn("InteractiveShell.{name} is deprecated, use PromptManager.{newname}".format(

name=name, newname=table[name])

)

# protect against weird cases where self.config may not exist:

if self.config is not None:

# propagate to corresponding PromptManager trait

setattr(self.config.PromptManager, table[name], new)

_prompt_in1_changed = _prompt_trait_changed

_prompt_in2_changed = _prompt_trait_changed

_prompt_out_changed = _prompt_trait_changed

_prompt_pad_left_changed = _prompt_trait_changed

show_rewritten_input = CBool(True, config=True,

help="Show rewritten input, e.g. for autocall."

)

quiet = CBool(False, config=True)

history_length = Integer(10000, config=True)

# The readline stuff will eventually be moved to the terminal subclass

# but for now, we can't do that as readline is welded in everywhere.

readline_use = CBool(True, config=True)

readline_remove_delims = Unicode('-/~', config=True)

readline_delims = Unicode() # set by init_readline()

# don't use \M- bindings by default, because they

# conflict with 8-bit encodings. See gh-58,gh-88

readline_parse_and_bind = List([

'tab: complete',

'"\C-l": clear-screen',

'set show-all-if-ambiguous on',

'"\C-o": tab-insert',

'"\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',

], allow_none=False, config=True)

ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none'],

default_value='last_expr', config=True,

help="""

run interactively (displaying output from expressions).""")

# TODO: this part of prompt management should be moved to the frontends.

# Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'

separate_in = SeparateUnicode('\n', config=True)

separate_out = SeparateUnicode('', config=True)

separate_out2 = SeparateUnicode('', config=True)

wildcards_case_sensitive = CBool(True, config=True)

xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),

default_value='Context', config=True)

# Subcomponents of InteractiveShell

alias_manager = Instance('IPython.core.alias.AliasManager')

prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')

builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')

display_trap = Instance('IPython.core.display_trap.DisplayTrap')

extension_manager = Instance('IPython.core.extensions.ExtensionManager')

payload_manager = Instance('IPython.core.payload.PayloadManager')

history_manager = Instance('IPython.core.history.HistoryManager')

magics_manager = Instance('IPython.core.magic.MagicsManager')

profile_dir = Instance('IPython.core.application.ProfileDir')

@property

def profile(self):

if self.profile_dir is not None:

name = os.path.basename(self.profile_dir.location)

return name.replace('profile_','')

# Private interface

_post_execute = Instance(dict)

# Tracks any GUI loop loaded for pylab

pylab_gui_select = None

def __init__(self, ipython_dir=None, profile_dir=None,

user_module=None, user_ns=None,

custom_exceptions=((), None), **kwargs):

# This is where traits with a config_key argument are updated

# from the values on config.

super(InteractiveShell, self).__init__(**kwargs)

self.configurables = [self]

# These are relatively independent and stateless

self.init_ipython_dir(ipython_dir)

self.init_profile_dir(profile_dir)

self.init_instance_attrs()

self.init_environment()

# Check if we're in a virtualenv, and set up sys.path.

self.init_virtualenv()

# Create namespaces (user_ns, user_global_ns, etc.)

self.init_create_namespaces(user_module, user_ns)

# This has to be done after init_create_namespaces because it uses

# something in self.user_ns, but before init_sys_modules, which

# is the first thing to modify sys.

# TODO: When we override sys.stdout and sys.stderr before this class

# is created, we are saving the overridden ones here. Not sure if this

# is what we want to do.

self.save_sys_module_state()

self.init_sys_modules()

# While we're trying to have each part of the code directly access what

# it needs without keeping redundant references to objects, we have too

# much legacy code that expects ip.db to exist.

self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))

self.init_history()

self.init_encoding()

self.init_prefilter()

self.init_syntax_highlighting()

self.init_hooks()

self.init_pushd_popd_magic()

# self.init_traceback_handlers use to be here, but we moved it below

# because it and init_io have to come after init_readline.

self.init_user_ns()

self.init_logger()

self.init_builtins()

# The following was in post_config_initialization

self.init_inspector()

# init_readline() must come before init_io(), because init_io uses

# readline related things.

self.init_readline()

# We save this here in case user code replaces raw_input, but it needs

# to be after init_readline(), because PyPy's readline works by replacing

# raw_input.

if py3compat.PY3:

self.raw_input_original = input

else:

self.raw_input_original = raw_input

# init_completer must come after init_readline, because it needs to

# know whether readline is present or not system-wide to configure the

# completers, since the completion machinery can now operate

# independently of readline (e.g. over the network)

self.init_completer()

# TODO: init_io() needs to happen before init_traceback handlers

# because the traceback handlers hardcode the stdout/stderr streams.

# This logic in in debugger.Pdb and should eventually be changed.

self.init_io()

self.init_traceback_handlers(custom_exceptions)

self.init_prompts()

self.init_display_formatter()

self.init_display_pub()

self.init_data_pub()

self.init_displayhook()

self.init_latextool()

self.init_magics()

self.init_alias()

self.init_logstart()

self.init_pdb()

self.init_extension_manager()

self.init_payload()

self.init_comms()

self.hooks.late_startup_hook()

atexit.register(self.atexit_operations)

def get_ipython(self):

"""Return the currently running IPython instance."""

return self

#-------------------------------------------------------------------------

# Trait changed handlers

#-------------------------------------------------------------------------

def _ipython_dir_changed(self, name, new):

if not os.path.isdir(new):

os.makedirs(new, mode = 0o777)

def set_autoindent(self,value=None):

"""Set the autoindent flag, checking for readline support.

if value != 0 and not self.has_readline:

if os.name == 'posix':

warn("The auto-indent feature requires the readline library")

self.autoindent = 0

return

if value is None:

self.autoindent = not self.autoindent

else:

self.autoindent = value

#-------------------------------------------------------------------------

# init_* methods called by __init__

#-------------------------------------------------------------------------

def init_ipython_dir(self, ipython_dir):

if ipython_dir is not None:

self.ipython_dir = ipython_dir

return

self.ipython_dir = get_ipython_dir()

def init_profile_dir(self, profile_dir):

if profile_dir is not None:

self.profile_dir = profile_dir

return

self.profile_dir =\

ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')

def init_instance_attrs(self):

self.more = False

# command compiler

self.compile = CachingCompiler()

# Make an empty namespace, which extension writers can rely on both

# existing and NEVER being used by ipython itself. This gives them a

# convenient location for storing additional information and state

# their extensions may require, without fear of collisions with other

# ipython names that may develop later.

self.meta = Struct()

# Temporary files used for various purposes. Deleted at exit.

self.tempfiles = []

# Keep track of readline usage (later set by init_readline)

self.has_readline = False

# keep track of where we started running (mainly for crash post-mortem)

# This is not being used anywhere currently.

self.starting_dir = py3compat.getcwd()

# Indentation management

self.indent_current_nsp = 0

# Dict to track post-execution functions that have been registered

self._post_execute = {}

def init_environment(self):

"""Any changes we need to make to the user's environment."""

pass

def init_encoding(self):

# Get system encoding at startup time. Certain terminals (like Emacs

# under Win32 have it set to None, and we need to have a known valid

# encoding to use in the raw_input() method

try:

self.stdin_encoding = sys.stdin.encoding or 'ascii'

except AttributeError:

self.stdin_encoding = 'ascii'

def init_syntax_highlighting(self):

# Python source parser/formatter for syntax highlighting

pyformat = PyColorize.Parser().format

self.pycolorize = lambda src: pyformat(src,'str',self.colors)

def init_pushd_popd_magic(self):

# for pushd/popd management

self.home_dir = get_home_dir()

self.dir_stack = []

def init_logger(self):

self.logger = Logger(self.home_dir, logfname='ipython_log.py',

logmode='rotate')

def init_logstart(self):

"""Initialize logging in case it was requested at the command line.

if self.logappend:

self.magic('logstart %s append' % self.logappend)

elif self.logfile:

self.magic('logstart %s' % self.logfile)

elif self.logstart:

self.magic('logstart')

def init_builtins(self):

# A single, static flag that we set to True. Its presence indicates

# that an IPython shell has been created, and we make no attempts at

# removing on exit or representing the existence of more than one

# IPython at a time.

builtin_mod.__dict__['__IPYTHON__'] = True

# In 0.11 we introduced '__IPYTHON__active' as an integer we'd try to

# manage on enter/exit, but with all our shells it's virtually

# impossible to get all the cases right. We're leaving the name in for

# those who adapted their codes to check for this flag, but will

# eventually remove it after a few more releases.

builtin_mod.__dict__['__IPYTHON__active'] = \

'Deprecated, check for __IPYTHON__'

self.builtin_trap = BuiltinTrap(shell=self)

def init_inspector(self):

# Object inspector

self.inspector = oinspect.Inspector(oinspect.InspectColors,

PyColorize.ANSICodeColors,

'NoColor',

self.object_info_string_level)

def init_io(self):

# This will just use sys.stdout and sys.stderr. If you want to

# override sys.stdout and sys.stderr themselves, you need to do that

# *before* instantiating this class, because io holds onto

# references to the underlying streams.

if (sys.platform == 'win32' or sys.platform == 'cli') and self.has_readline:

io.stdout = io.stderr = io.IOStream(self.readline._outputfile)

else:

io.stdout = io.IOStream(sys.stdout)

io.stderr = io.IOStream(sys.stderr)

def init_prompts(self):

self.prompt_manager = PromptManager(shell=self, parent=self)

self.configurables.append(self.prompt_manager)

# Set system prompts, so that scripts can decide if they are running

# interactively.

sys.ps1 = 'In : '

sys.ps2 = '...: '

sys.ps3 = 'Out: '

def init_display_formatter(self):

self.display_formatter = DisplayFormatter(parent=self)

self.configurables.append(self.display_formatter)

def init_display_pub(self):

self.display_pub = self.display_pub_class(parent=self)

self.configurables.append(self.display_pub)

def init_data_pub(self):

if not self.data_pub_class:

self.data_pub = None

return

self.data_pub = self.data_pub_class(parent=self)

self.configurables.append(self.data_pub)

def init_displayhook(self):

# Initialize displayhook, set in/out prompts and printing system

self.displayhook = self.displayhook_class(

parent=self,

shell=self,

cache_size=self.cache_size,

)

self.configurables.append(self.displayhook)

# This is a context manager that installs/revmoes the displayhook at

# the appropriate time.

self.display_trap = DisplayTrap(hook=self.displayhook)

def init_latextool(self):

"""Configure LaTeXTool."""

cfg = LaTeXTool.instance(parent=self)

if cfg not in self.configurables:

self.configurables.append(cfg)

def init_virtualenv(self):

"""Add a virtualenv to sys.path so the user can import modules from it.

if 'VIRTUAL_ENV' not in os.environ:

# Not in a virtualenv

return

if os.path.realpath(sys.executable).startswith(

os.path.realpath(os.environ['VIRTUAL_ENV'])

):

# Running properly in the virtualenv, don't need to do anything

return

warn("Attempting to work in a virtualenv. If you encounter problems, please "

"install IPython inside the virtualenv.")

if sys.platform == "win32":

virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages')

else:

virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',

'python%d.%d' % sys.version_info[:2], 'site-packages')

import site

sys.path.insert(0, virtual_env)

site.addsitedir(virtual_env)

#-------------------------------------------------------------------------

# Things related to injections into the sys module

#-------------------------------------------------------------------------

def save_sys_module_state(self):

"""Save the state of hooks in the sys module.

self._orig_sys_module_state = {}

self._orig_sys_module_state['stdin'] = sys.stdin

self._orig_sys_module_state['stdout'] = sys.stdout

self._orig_sys_module_state['stderr'] = sys.stderr

self._orig_sys_module_state['excepthook'] = sys.excepthook

self._orig_sys_modules_main_name = self.user_module.__name__

self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)

def restore_sys_module_state(self):

"""Restore the state of the sys module."""

try:

for k, v in iteritems(self._orig_sys_module_state):

setattr(sys, k, v)

except AttributeError:

pass

# Reset what what done in self.init_sys_modules

if self._orig_sys_modules_main_mod is not None:

sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod

#-------------------------------------------------------------------------

# Things related to hooks

#-------------------------------------------------------------------------

def init_hooks(self):

# hooks holds pointers used for user-side customizations

self.hooks = Struct()

self.strdispatchers = {}

# Set all default hooks, defined in the IPython.hooks module.

hooks = IPython.core.hooks

for hook_name in hooks.__all__:

# default hooks have priority 100, i.e. low; user hooks should have

# 0-100 priority

self.set_hook(hook_name,getattr(hooks,hook_name), 100)

def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):

"""set_hook(name,hook) -> sets an internal IPython hook.

# At some point in the future, this should validate the hook before it

# accepts it. Probably at least check that the hook takes the number

# of args it's supposed to.

f = types.MethodType(hook,self)

# check if the hook is for strdispatcher first

if str_key is not None:

sdp = self.strdispatchers.get(name, StrDispatch())

sdp.add_s(str_key, f, priority )

self.strdispatchers[name] = sdp

return

if re_key is not None:

sdp = self.strdispatchers.get(name, StrDispatch())

sdp.add_re(re.compile(re_key), f, priority )

self.strdispatchers[name] = sdp

return

dp = getattr(self.hooks, name, None)

if name not in IPython.core.hooks.__all__:

print("Warning! Hook '%s' is not one of %s" % \

(name, IPython.core.hooks.__all__ ))

if not dp:

dp = IPython.core.hooks.CommandChainDispatcher()

try:

dp.add(f,priority)

except AttributeError:

# it was not commandchain, plain old func - replace

dp = f

setattr(self.hooks,name, dp)

def register_post_execute(self, func):

"""Register a function for calling after code execution.

if not callable(func):

raise ValueError('argument %s must be callable' % func)

self._post_execute[func] = True

#-------------------------------------------------------------------------

# Things related to the "main" module

#-------------------------------------------------------------------------

def new_main_mod(self, filename, modname):

"""Return a new 'main' module object for user code execution.

filename = os.path.abspath(filename)

try:

main_mod = self._main_mod_cache[filename]

except KeyError:

main_mod = self._main_mod_cache[filename] = types.ModuleType(modname,

doc="Module created for script run in IPython")

else:

main_mod.__dict__.clear()

main_mod.__name__ = modname

main_mod.__file__ = filename

# It seems pydoc (and perhaps others) needs any module instance to

# implement a __nonzero__ method

main_mod.__nonzero__ = lambda : True

return main_mod

def clear_main_mod_cache(self):

"""Clear the cache of main modules.

self._main_mod_cache.clear()

#-------------------------------------------------------------------------

# Things related to debugging

#-------------------------------------------------------------------------

def init_pdb(self):

# Set calling of pdb on exceptions

# self.call_pdb is a property

self.call_pdb = self.pdb

def _get_call_pdb(self):

return self._call_pdb

def _set_call_pdb(self,val):

if val not in (0,1,False,True):

raise ValueError('new call_pdb value must be boolean')

# store value in instance

self._call_pdb = val

# notify the actual exception handlers

self.InteractiveTB.call_pdb = val

call_pdb = property(_get_call_pdb,_set_call_pdb,None,

'Control auto-activation of pdb at exceptions')

def debugger(self,force=False):

"""Call the pydb/pdb debugger.

if not (force or self.call_pdb):

return

if not hasattr(sys,'last_traceback'):

error('No traceback has been produced, nothing to debug.')

return

# use pydb if available

if debugger.has_pydb:

from pydb import pm

else:

# fallback to our internal debugger

pm = lambda : self.InteractiveTB.debugger(force=True)

with self.readline_no_record:

pm()

#-------------------------------------------------------------------------

# Things related to IPython's various namespaces

#-------------------------------------------------------------------------

default_user_namespaces = True

def init_create_namespaces(self, user_module=None, user_ns=None):

# Create the namespace where the user will operate. user_ns is

# normally the only one used, and it is passed to the exec calls as

# the locals argument. But we do carry a user_global_ns namespace

# given as the exec 'globals' argument, This is useful in embedding

# situations where the ipython shell opens in a context where the

# distinction between locals and globals is meaningful. For

# non-embedded contexts, it is just the same object as the user_ns dict.

# FIXME. For some strange reason, __builtins__ is showing up at user

# level as a dict instead of a module. This is a manual fix, but I

# should really track down where the problem is coming from. Alex

# Schmolck reported this problem first.

# A useful post by Alex Martelli on this topic:

# Re: inconsistent value from __builtins__

# Von: Alex Martelli <aleaxit@yahoo.com>

# Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends

# Gruppen: comp.lang.python

# Michael Hohn <hohn@hooknose.lbl.gov> wrote:

# > >>> print type(builtin_check.get_global_binding('__builtins__'))

# > <type 'dict'>

# > >>> print type(__builtins__)

# > <type 'module'>

# > Is this difference in return value intentional?

# Well, it's documented that '__builtins__' can be either a dictionary

# or a module, and it's been that way for a long time. Whether it's

# intentional (or sensible), I don't know. In any case, the idea is

# that if you need to access the built-in namespace directly, you

# should start with "import __builtin__" (note, no 's') which will

# definitely give you a module. Yeah, it's somewhat confusing:-(.

# These routines return a properly built module and dict as needed by

# the rest of the code, and can also be used by extension writers to

# generate properly initialized namespaces.

if (user_ns is not None) or (user_module is not None):

self.default_user_namespaces = False

self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)

# A record of hidden variables we have added to the user namespace, so

# we can list later only variables defined in actual interactive use.

self.user_ns_hidden = {}

# Now that FakeModule produces a real module, we've run into a nasty

# problem: after script execution (via %run), the module where the user

# code ran is deleted. Now that this object is a true module (needed

# so docetst and other tools work correctly), the Python module

# teardown mechanism runs over it, and sets to None every variable