init_session(auto_symbols=True) and init_session(auto_int_to_Integer=True) do not work

[asmeurer]

In [5]: init_session(auto_int_to_Integer=True, auto_symbols=True)
IPython console for SymPy 0.7.4.1-git (Python 3.3.3-64-bit) (ground types: python)

These commands were executed:
>>> from __future__ import division
>>> from sympy import *
>>> x, y, z, t = symbols('x y z t')
>>> k, m, n = symbols('k m n', integer=True)
>>> f, g, h = symbols('f g h', cls=Function)

Documentation can be found at http://www.sympy.org

In [6]: 1/2
Out[6]: 0.5

In [7]: notdefined
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-7-6ee7e72db811> in <module>()
----> 1 notdefined

NameError: name 'notdefined' is not defined

isympy -I works.

We need to convert these to use the new IPython ast machinery.

[asmeurer]

@takluyver could you point me to the docs for the new ast stuff? Also, do you remember if I or you ever figured out a working example for undefined names. I seem to remember that one was nontrivial to get right?

[takluyver]

Sure, the docs are here: http://ipython.org/ipython-doc/stable/config/inputtransforms.html#ast-transformations

I don't think we ever wrote an actual example. I think it's fairly straightforward if you don't need to support names first appearing within function definitions:

• Scan the code for Name nodes with ctx=Del().
• Implement visit_FunctionDef and visit_ClassDef as no-ops so we don't scan code in those.
• Check names found against user_ns.
• For any that don't already exist, insert AST nodes equivalent to foo = symbol('foo') at the top of the cell.
• If the variable is defined in that cell, then that definition comes after the one we just added, so the variable is redefined to the value the user expects.

Supporting variables in function definitions is a bit trickier, because you presumably don't want to leak those definitions out to the global scope. But it should be feasible to keep a stack of references to function definitions, and insert the foo = symbol('foo') into the function at the top of the stack.

[asmeurer]

I think it's fine to not support functions.

I was worried about names that are defined within the block, but I just realized that this doesn't matter. It will just end up being a redefinition instead. Creating symbols is cheap and side-effect free, so there's no issues there.

Why ctx=Del()? I don't understand why it shouldn't be ctx=Load().

[takluyver]

Yep, I had the same worry and the same realisation.

It should be ctx=Load(), I evidently had a brainfart. ;-)

[jcrist]

Copying this over from #2921, and then closing that issue (duplicate):

Quote:
"TODO from sympy/interactive/session.py (commented out code, deleted in #2219):

# XXX: Something like this might be used, but it only works on single line
# inputs.  See
# http://mail.scipy.org/pipermail/ipython-user/2012-August/010846.html and
# https://github.com/ipython/ipython/issues/1491.  So instead we are forced to
# just monkey-patch run_cell until IPython builds a better API.
 class IntTransformer(object):
     """
     IPython command line transformer that recognizes and replaces int
     literals.

     Based on
     https://bitbucket.org/birkenfeld/ipython-physics/src/71b2d850da00/physics.py.

     """
     priority = 99
     enabled = True
     def transform(self, line, continue_prompt):
         import re
         from tokenize import TokenError
         leading_space = re.compile(' *')
         spaces = re.match(leading_space, line).span()[1]
         try:
             return ' '*spaces + int_to_Integer(line)
         except TokenError:
             return line

 int_transformer = IntTransformer()

 def enable_automatic_int_sympification(app):
     """
     Allow IPython to automatically convert integer literals to Integer.

     This lets things like 1/2 be executed as (essentially) Rational(1, 2).
     """
     app.shell.prefilter_manager.register_transformer(int_transformer)

"

[takluyver]

As described above, we did build a better API - AST transformations. There's an example of how it works in the tests:

https://github.com/ipython/ipython/blob/411cd57051173af49a54f55bfce9c22198bc43e8/IPython/core/tests/test_interactiveshell.py#L616

[mhlr]

I have found a workaround for this. The problem is that when in an already running IPython session, init_session does not call init_ipython_session which is responsible for enabling the options as well as starting the session. That call can be made explicitly first:

sympy.interactive import init_session
from sympy.interactive.session import init_ipython_session
init_ipython_session(auto_symbols=True, auto_int_to_Integer=True)
init_session(ipython=None, auto_symbols=True, auto_int_to_Integer=True)

See http://stackoverflow.com/a/42105135/843348

[asmeurer]

@mhlr so I guess the if ip is None check before it calls init_ipython_session should be removed. Are there downsides to calling it twice? I tested your workaround and it seems to work. Can you send a patch?

[mhlr]

@asmeurer I do not know if there are downsides. I have not observed any, but this is the first time I have really looked inside sympy source and I have only started using this method.
There is still the problem that the initialization need to be done separately, eg doing eval-buffer from emacs does not work.

I am happy to make a patch if you think this is good.

[asmeurer]

Yes, please send a patch.

[mhlr]

@asmeurer Ok. So I will just remove the if statement.

Also do you think wrapping the initialization in an IPython magic would fix the problem with needing separate evaluations?

[asmeurer]

I don't know. Having a magic command sounds useful either way, though.