def __init__(self,test_filename):

self.test_filename = test_filename

def __call__(self,name):

from IPython.utils.path import get_py_filename

try:

return get_py_filename(name)

except IOError:

test_dir = os.path.dirname(self.test_filename)

new_path = os.path.join(test_dir,name)

"""Modified version of %run that syncs testing namespaces.

#print('in run_ns_sync', arg_s, file=sys.stderr) # dbg

finder = py_file_finder(arg_s)

"""A special subclass of dict for use as an IPython namespace in doctests.

def __init__(self,*a):

dict.__init__(self,*a)

self._savedict = {}

def clear(self):

dict.clear(self)

self.update(self._savedict)

def _checkpoint(self):

self._savedict.clear()

self._savedict.update(self)

def update(self,other):

self._checkpoint()

dict.update(self,other)

# If '_' is in the namespace, python won't set it when executing code,

# and we have examples that test it. So we ensure that the namespace

# is always 'clean' of it before it's used for test code execution.

self.pop('_',None)

# The builtins namespace must *always* be the real __builtin__ module,

# else weird stuff happens. The main ipython code does have provisions

# to ensure this after %run, but since in this class we do some

# aggressive low-level cleaning of the execution namespace, we need to

# correct for that ourselves, to ensure consitency with the 'real'

# ipython.

"""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).rstrip(), end='', file=sys.stdout)

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

user_ns=ipnsdict(),

user_global_ns={}

)

# A few more tweaks needed for playing nicely with doctests...

# 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 = MethodType(xsys, shell, TerminalInteractiveShell)

shell._showtraceback = MethodType(_showtraceback, shell,

TerminalInteractiveShell)

# 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__._ip = _ip

__builtin__.get_ipython = get_ipython