isympy

#!/usr/bin/env python

# XXX: Don't put a newline here, or it will add an extra line with
# isympy --help
#  |
#  v
"""Python shell for SymPy.

This is just a normal Python shell (IPython shell if you have the
IPython package installed), that executes the following commands for
the user:

    >>> 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)

So starting 'isympy' is equivalent to starting Python (or IPython) and
executing the above commands by hand.  It is intended for easy and quick
experimentation with SymPy.  isympy is a good way to use SymPy as an
interactive calculator

COMMAND LINE OPTIONS
--------------------

-c CONSOLE, --console=CONSOLE

     Use the specified shell (Python or IPython) shell as the console
     backend instead of the default one (IPython if present, Python
     otherwise), e.g.:

        $isympy -c python

    CONSOLE must be one of 'ipython' or 'python'

-p PRETTY, --pretty PRETTY

    Setup pretty printing in SymPy. By default the most pretty, unicode
    printing is enabled (if the terminal supports it). You can use less
    pretty ASCII printing instead or no pretty printing at all, e.g.:

        $isympy -p no

    PRETTY must be one of 'unicode', 'ascii', or 'no'

-t TYPES, --types=TYPES

    Setup the ground types for the polys.  By default, gmpy ground types
    are used if gmpy is installed, otherwise it falls back to python
    ground types, which are a little bit slower.  You can manually
    choose python ground types even if gmpy is installed (e.g., for
    testing purposes), e.g.:

        $isympy -t python

    TYPES must be one of 'gmpy', 'python', or 'sympy'

    Note that sympy ground types are not supported, and should be used
    only for experimental purposes.

    This is the same as setting the environment variable
    SYMPY_GROUND_TYPES to the given ground type (e.g.,
    SYMPY_GROUND_TYPES='gmpy')

    The ground types can be determined interactively from the variable
    sympy.polys.domains.GROUND_TYPES.

-o ORDER, --order ORDER

    Setup the ordering of terms for printing.  The default is lex, which
    orders terms lexicographically (e.g., x**2 + x + 1). You can choose
    other orderings, such as rev-lex, which will use reverse
    lexicographic ordering (e.g., 1 + x + x**2), e.g.:

        $isympy -o rev-lex

    ORDER must be one of 'lex', 'rev-lex', 'grlex', 'rev-grlex',
    'grevlex', 'rev-grevlex', 'old', or 'none'.

    Note that for very large expressions, ORDER='none' may speed up
    printing considerably, with the tradeoff that the order of the terms
    in the printed expression will have no canonical order.

-q, --quiet

    Print only Python's and SymPy's versions to stdout at startup.

-d, --doctest

    Use the same format that should be used for doctests.  This is
    equivalent to -c python -p no.

-C, --no-cache

    Disable the caching mechanism.  Disabling the cache may slow certain
    operations down considerably.  This is useful for testing the cache,
    or for benchmarking, as the cache can result in deceptive timings.

    This is the same as setting the environment variable SYMPY_USE_CACHE
    to 'no'.

    This is equivalent to setting the environment variable
    SYMPY_USE_CACHE='no'.

-a, --auto

    Automatically create missing symbols.  Normally, typing a name of a
    Symbol that has not been instantiated first would raise NameError,
    but with this option enabled, any undefined name will be
    automatically created as a Symbol.  This only works in IPython 0.11.

    Note that this is intended only for interactive, calculator style
    usage. In a script that uses SymPy, Symbols should be instantiated
    at the top, so that it's clear what they are.

    This will not override any names that are already defined, which
    includes the single character letters represented by the mnemonic
    QCOSINE (see the "Gotchas and Pitfalls" document in the
    documentation). You can delete existing names by executing "del
    name".  You can see if a name is defined by typing "'name' in
    globals()".

    The Symbols that are created using this have default assumptions.
    If you want to place assumptions on symbols, you should create them
    using symbols() or var().

    Finally, this only works in the top level namespace. So, for
    example, if you define a function in isympy with an undefined
    Symbol, it will not work.

-D, --debug

    Enable debugging output.  This is the same as setting the
    environment variable SYMPY_DEBUG to 'True'.  The debug status is set
    in the variable SYMPY_DEBUG within isympy.

-- IPython options

    Additionally you can pass command line options directly to the
    IPython interpreter (the standard Python shell is not supported).
    However you need to add '--' separator between two types of options.
    To run SymPy without startup banner and colors, for example, issue in IPython 0.11 or higher:

        $isympy -q -- --colors=NoColor

    Or in an older version of IPython:

        $isympy -q -- -colors NoColor

See also isympy --help.
"""

import os, sys, warnings


# hook in-tree SymPy into Python path, if possible

isympy_path = os.path.abspath(__file__)
isympy_dir  = os.path.dirname(isympy_path)
sympy_top   = os.path.split(isympy_dir)[0]
sympy_dir   = os.path.join(sympy_top, 'sympy')

if os.path.isdir(sympy_dir):
    sys.path.insert(0, sympy_top)

def main():
    from optparse import OptionParser

    if '-h' in sys.argv or '--help' in sys.argv:
        # XXX: We can't use description=__doc__  in the OptionParser call
        # below because optparse line wraps it weird.  The argparse module
        # allows you to disable this, though, but it's only available in
        # Python 2.7+.
        print __doc__ # the docstring of this module above
    usage = 'usage: isympy [options] -- [ipython options]'
    parser = OptionParser(
        usage=usage,
        version='0.7.1-git',
        # XXX: We need a more centralized place to store the version.
        # It is currently stored in sympy.__version__, but we can't yet
        # import sympy at this point.
        )

    parser.add_option(
        '-c', '--console',
        dest='console',
        action='store',
        default=None,
        choices=['ipython', 'python'],
        help='select type of interactive session: ipython | python; defaults '
        'to ipython if IPython is installed, otherwise python')

    parser.add_option(
        '-p', '--pretty',
        dest='pretty',
        action='store',
        default=None,
        choices=['unicode', 'ascii', 'no'],
        help='setup pretty printing: unicode | ascii | no; defaults to '
        'unicode printing if the terminal supports it, otherwise ascii')

    parser.add_option(
        '-t', '--types',
        dest='types',
        action='store',
        default=None,
        choices=['gmpy', 'python', 'sympy'],
        help='setup ground types: gmpy | python | sympy; defaults to gmpy if '
        'gmpy is installed, otherwise python (note that sympy ground types are '
        'not supported and should be used for experimental purposes only)')

    parser.add_option(
        '-o', '--order',
        dest='order',
        action='store',
        default=None,
        choices=['lex', 'grlex', 'grevlex', 'rev-lex', 'rev-grlex', 'rev-grevlex', 'old', 'none'],
        help='setup ordering of terms: [rev-]lex | [rev-]grlex | [rev-]grevlex | old | none; defaults to lex')

    parser.add_option(
        '-q', '--quiet',
        dest='quiet',
        action='store_true',
        default=False,
        help='print only version information at startup')

    parser.add_option(
        '-d', '--doctest',
        dest='doctest',
        action='store_true',
        default=False,
        help='use the doctest format for output (you can just copy and paste it)')

    parser.add_option(
        '-C', '--no-cache',
        dest='cache',
        action='store_false',
        default=True,
        help='disable caching mechanism')

    parser.add_option(
        '-a', '--auto',
        dest='auto',
        action='store_true',
        default=False,
        help='automatically construct missing symbols')

    parser.add_option(
        '-D', '--debug',
        dest='debug',
        action='store_true',
        default=False,
        help='enable debugging output')

    (options, ipy_args) = parser.parse_args()

    if not options.cache:
        os.environ['SYMPY_USE_CACHE'] = 'no'

    if options.types:
        os.environ['SYMPY_GROUND_TYPES'] = options.types

    if options.debug:
        os.environ['SYMPY_DEBUG'] = str(options.debug)

    if options.doctest:
        options.pretty = 'no'
        options.console = 'python'

    session = options.console

    if session is not None:
        ipython = session == 'ipython'
    else:
        ipython = None

    args = {
        'pretty_print' : True,
        'use_unicode'  : None,
        'order'        : None,
        'argv'         : ipy_args,
    }

    if options.pretty == 'unicode':
        args['use_unicode'] = True
    elif options.pretty == 'ascii':
        args['use_unicode'] = False
    elif options.pretty == 'no':
        args['pretty_print'] = False

    if options.order is not None:
        args['order'] = options.order

    args['quiet'] = options.quiet
    args['auto'] = options.auto

    from sympy.utilities.exceptions import SymPyDeprecationWarning
    warnings.simplefilter("always", SymPyDeprecationWarning)

    from sympy.interactive import init_session
    init_session(ipython, **args)

if __name__ == "__main__":
    main()