ENH: Allow non-dict namespaces. This involves a change in the ipapi for setting user namespaces.

IPython/ipapi.py

@@ -566,7 +566,46 b' def make_user_ns(user_ns = None):'
     classes in ipython.
     """
 
+    raise NotImplementedError
+
+
+def make_user_global_ns(ns = None):
+    """Return a valid user global namespace.
+
+    Similar to make_user_ns(), but global namespaces are really only needed in
+    embedded applications, where there is a distinction between the user's
+    interactive namespace and the global one where ipython is running."""
+
+    raise NotImplementedError
+
+# Record the true objects in order to be able to test if the user has overridden
+# these API functions.
+_make_user_ns = make_user_ns
+_make_user_global_ns = make_user_global_ns
+
+
+def make_user_namespaces(user_ns = None,user_global_ns = None):
+    """Return a valid local and global user interactive namespaces.
+
+    This builds a dict with the minimal information needed to operate as a
+    valid IPython user namespace, which you can pass to the various embedding
+    classes in ipython.  The default implementation returns the same dict for
+    both the locals and the globals to allow functions to refer to variables in
+    the namespace.  Customized implementations can return different dicts.  The
+    locals dictionary can actually be anything following the basic mapping
+    protocol of a dict, but the globals dict must be a true dict, not even
+    a subclass.  It is recommended that any custom object for the locals
+    namespace synchronize with the globals dict somehow.
+
+    Raises TypeError if the provided globals namespace is not a true dict.
+    """
+
     if user_ns is None:
+        if make_user_ns is not _make_user_ns:
+            # Old API overridden.
+            # FIXME: Issue DeprecationWarning, or just let the old API live on?
+            user_ns = make_user_ns(user_ns)
+        else:
         # Set __name__ to __main__ to better match the behavior of the
         # normal interpreter.
         user_ns = {'__name__'     :'__main__',
@@ -576,18 +615,17 b' def make_user_ns(user_ns = None):'
         user_ns.setdefault('__name__','__main__')
         user_ns.setdefault('__builtins__',__builtin__)
 
-    return user_ns
-
-
-def make_user_global_ns(ns = None):
-    """Return a valid user global namespace.
-
-    Similar to make_user_ns(), but global namespaces are really only needed in
-    embedded applications, where there is a distinction between the user's
-    interactive namespace and the global one where ipython is running."""
+    if user_global_ns is None:
+        if make_user_global_ns is not _make_user_global_ns:
+            # Old API overridden.
+            user_global_ns = make_user_global_ns(user_global_ns)
+        else:
+            user_global_ns = user_ns
+    if type(user_global_ns) is not dict:
+        raise TypeError("user_global_ns must be a true dict; got %r"
+            % type(user_global_ns))
 
-    if ns is None: ns = {}
-    return ns
+    return user_ns, user_global_ns
 
 
 def make_session(user_ns = None, shellclass = None):

IPython/iplib.py

@@ -215,10 +215,11 b' class InteractiveShell(object,Magic):'
 
         # some minimal strict typechecks.  For some core data structures, I
         # want actual basic python types, not just anything that looks like
-        # one.  This is especially true for namespaces.
-        for ns in (user_ns,user_global_ns):
-            if ns is not None and type(ns) != types.DictType:
-                raise TypeError,'namespace must be a dictionary'
+        # one.  This is especially true for the global namespace.
+        if user_global_ns is not None and type(user_global_ns) is not dict:
+            raise TypeError('global namespace must be a true dict; got %r'
+                % type(user_global_ns))
+
         # Job manager (for jobs run as background threads)
         self.jobs = BackgroundJobManager()
 
@@ -260,7 +261,8 b' class InteractiveShell(object,Magic):'
         # 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.
+        # 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
@@ -290,14 +292,12 b' class InteractiveShell(object,Magic):'
         # These routines return properly built dicts as needed by the rest of
         # the code, and can also be used by extension writers to generate
         # properly initialized namespaces.
-        user_ns = IPython.ipapi.make_user_ns(user_ns)
-        user_global_ns = IPython.ipapi.make_user_global_ns(user_global_ns)
+        user_ns, user_global_ns = IPython.ipapi.make_user_namespaces(user_ns,
+            user_global_ns)
             
         # Assign namespaces
         # This is the namespace where all normal user variables live
         self.user_ns = user_ns
-        # Embedded instances require a separate namespace for globals.
-        # Normally this one is unused by non-embedded instances.
         self.user_global_ns = user_global_ns
         # A namespace to keep track of internal data structures to prevent
         # them from cluttering user-visible stuff.  Will be updated later
@@ -2066,16 +2066,7 b' want to merge them back into the new files.""" % locals()'
         try:
             try:
                 self.hooks.pre_runcode_hook()
-                # Embedded instances require separate global/local namespaces
-                # so they can see both the surrounding (local) namespace and
-                # the module-level globals when called inside another function.
-                if self.embedded:
                     exec code_obj in self.user_global_ns, self.user_ns
-                # Normal (non-embedded) instances should only have a single
-                # namespace for user code execution, otherwise functions won't
-                # see interactive top-level globals.
-                else:
-                    exec code_obj in self.user_ns
             finally:
                 # Reset our crash handler in place
                 sys.excepthook = old_excepthook