Ticket #7482: sagenb_7482.4.patch

sagenb/misc/support.py

@@ -10 +10 @@
 
 import inspect
 import os
+import base64
 import string
 import sys
 import __builtin__
@@ -95 +96 @@
 
        This a wrapper around the built-in help. If formats the output
        as HTML without word wrap, which looks better in the notebook.
-    
+
     INPUT:
     
     -  ``obj`` - a Python object, module, etc.
@@ -150 +151 @@
     
     - ``system`` - a string (default: 'None'); system prefix for the
       completions
+
+    OUTPUT:
+
+    - a list of strings, if ``format`` is False, or a string
     """
     if system not in ['sage', 'python']:
         prepend = system + '.'
@@ -538 +543 @@
         """
         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
+        :meth:`__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 :exc:`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`` -- a 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`` -- a boolean (default: None); whether to turn
+          automatic variable creation and functional calling on or off
+
+        OUTPUT:
+
+        - a boolean, if ``state`` is None; otherwise, None
+
+        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 :class:`AutomaticVariable` class derived from
+        :class:`~sage.symbolic.all.Expression`.  An instance of
+        :class:`AutomaticVariable` is a specific symbolic variable,
+        but with a special :meth:`~AutomaticVariable.__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
+        :exc:`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, globals):
     """
     Preparse the contents of a worksheet cell in the notebook,
     respecting the user using ``preparser(False)`` to turn off the
-    preparser.  This function calls ``preparse_file`` which also
-    reloads attached files.  It also does displayhook formatting by
-    calling the format.displayhook_hack function.
+    preparser.  This function calls
+    :func:`~sage.misc.preparser.preparse_file` which also reloads
+    attached files.  It also does displayhook formatting by calling
+    the :func:`~sagenb.notebook.interfaces.format.displayhook_hack`
+    function.
 
     INPUT:
 
-        - `s` -- string containing code
+    - ``s`` - a string containing code
+
+    - ``globals`` - a string:object dictionary; passed directly to
+      :func:`~sage.misc.preparser.preparse_file`
 
     OUTPUT:
 
-        - string
+        - a string
     """
     if do_preparse(): 
         s = preparse_file(s, globals=globals)
-    return displayhook_hack(s)
+    s = displayhook_hack(s)
+    if _automatic_names:
+        s = automatic_name_filter(s)
+    return s