Ticket #7482: sagenb_7482.3.patch

sagenb/misc/support.py

@@ -10 +10 @@
 
 import inspect
 import os
+import base64
 import string
 import sys
 import __builtin__
@@ -538 +539 @@
         """
         return False
 
+
+########################################################################
+#
+# Automatic Creation of Variable Names
+#
+# See the docstring for automatic_names below for an explanation of how
+# this works. 
+#
+########################################################################
+
+_automatic_names = False
+# We wrap everything in a try/catch, in case this is being imported
+# without the sage library present, e.g., in FEMhub.
+try:
+    from sage.symbolic.all import Expression, SR
+    class AutomaticVariable(Expression):
+        """
+        An automatically created symbolic variable with an additional
+        __call__ method designed so that doing self(foo,...) results
+        in foo.self(...).
+        """
+        def __call__(self, *args, **kwds):
+            """
+            Call method such that self(foo, ...) is transformed into
+            foo.self(...).  Note that self(foo=...,...) is not
+            transformed, it is treated as a normal symbolic
+            substitution.
+            """
+            if len(args) == 0:
+                return Expression.__call__(self, **kwds)
+            return args[0].__getattribute__(str(self))(*args[1:], **kwds)
+
+    def automatic_name_eval(s, globals, max_names=10000):
+        """
+        Exec the string s in the scope of the globals dictionary, and
+        if any NameError's are raised, try to fix them by defining the
+        variable that caused the error to be raised, then eval again.
+        Try up to max_names times.
+        
+        INPUT:
+
+           - `s` -- string
+           - ``globals`` -- a dictionary
+           - ``max_names`` -- a positive integer (default: 10000)
+        """
+        # This entire automatic naming system really boils down to
+        # this bit of code below.  We simply try to exec the string s
+        # in the globals namespace, defining undefined variables and
+        # functions until everything is defined.
+        for _ in range(max_names):
+            try:
+                exec s in globals
+                return
+            except NameError, msg:
+                # Determine if we hit a NameError that is probably
+                # caused by a variable or function not being defined:
+                if len(msg.args) == 0: raise  # not NameError with specific variable name
+                v = msg.args[0].split("'")
+                if len(v) < 2: raise  # also not NameError with specific variable name
+                # We did find an undefined variable: we simply define it and try again.
+                nm = v[1]
+                globals[nm] = AutomaticVariable(SR, SR.var(nm))
+        raise NameError, "Too many automatic variable names and functions created (limit=%s)"%max_names
+
+    def automatic_name_filter(s):
+        """
+        Wrap the string `s` in a call that will cause evaluation of
+        `s` to automatically create undefined variable names.
+
+        INPUT:
+
+           - `s` -- a string
+
+        OUTPUT:
+
+           - a string
+        """
+        return '_support_.automatic_name_eval(_support_.base64.b64decode("%s"),globals())'%base64.b64encode(s)
+
+    def automatic_names(state=None):
+        """
+        Turn automatic creation of variables and functional calling of
+        methods on or off.  Returns the current state if no argument is
+        given.
+
+        This ONLY works in the Sage notebook.  It is not supported on the
+        command line.
+
+        INPUT:
+
+            - ``state`` -- None or bool
+
+        EXAMPLES::
+
+            sage: automatic_names(True)      # not tested
+            sage: x + y + z                  # not tested
+            x + y + z
+
+        Here, trig_expand, y, and theta are all automatically
+        created::
+        
+            sage: trig_expand((2*x + 4*y + sin(2*theta))^2)   # not tested
+            4*(sin(theta)*cos(theta) + x + 2*y)^2
+            
+        IMPLEMENTATION: Here's how this works, internally.  We define
+        an AutomaticVariable class derived from Expression.  An
+        instance of AutomaticVariable is a specific symbolic variable,
+        but with a special call method.  We overload the call method
+        so that ``foo(bar, ...)`` gets transformed to ``bar.foo(...)``.  At
+        the same time, we still want expressions like `f^2 - b` to
+        work, i.e., we don't want to have to figure out whether a name
+        appearing in a NameError is meant to be a symbolic variable or
+        a function name. Instead, we just make an object that is both!
+
+        This entire approach is very simple---we do absolutely no
+        parsing of the actual input.  The actual real work amounts to
+        only a few lines of code.  The primary catch to this approach
+        is that if you evaluate a big block of code in the notebook,
+        and the first few lines take a long time, and the next few
+        lines define 10 new variables, the slow first few lines will
+        be evaluated 10 times.  Of course, the advantage of this
+        approach is that even very subtle code that might inject
+        surprisingly named variables into the namespace will just work
+        correctly, which would be impossible to guarantee with static
+        parsing, no matter how sophisticated it is.  Finally, given
+        the target audience: people wanting to simplify use of Sage
+        for Calculus for undergrads, I think this is an acceptable
+        tradeoff, especially given that this implementation is so
+        simple.
+        """
+        global _automatic_names
+        if state is None:
+            return _automatic_names
+        _automatic_names = bool(state)
+        
+except ImportError:
+    
+    pass
+
 from sagenb.interfaces.format import displayhook_hack
+
 def preparse_worksheet_cell(s):
     """
     Preparse the contents of a worksheet cell in the notebook,
@@ -557 +698 @@
     """
     if do_preparse(): 
         s = preparse_file(s, magic=True, do_time=True, ignore_prompts=False, reload_attached=True)
-    return displayhook_hack(s)
+    s = displayhook_hack(s)
+    if _automatic_names:
+        s = automatic_name_filter(s)
+    return s
+

sagenb/notebook/worksheet.py

@@ -3624 +3624 @@
 
     def preparse(self, s):
         return 'exec _support_.preparse_worksheet_cell(base64.b64decode("%s"))'%base64.b64encode(s)
-    #return 'exec _support_.displayhook_hack(_support_.preparse_file(base64.b64decode("%s"),magic=True,do_time=True,ignore_prompts=False,reload_attached=True))'%base64.b64encode(s)
-
+    
+    
     ##########################################################
     # Loading and attaching files
     ##########################################################