algebra_with_sympy.preparser

  1def algebra_with_sympy_preparser(lines):
  2    """
  3    In IPython compatible environments (Jupyter, IPython, etc...) this supports
  4    a special compact input method for equations.
  5
  6    The syntax supported is `equation_name =@ equation.lhs = equation.rhs`,
  7    where `equation_name` is a valid Python name that can be used to refer to
  8    the equation later. `equation.lhs` is the left-hand side of the equation
  9    and `equation.rhs` is the right-hand side of the equation. Each side of the
 10    equation must parse into a valid Sympy expression.
 11
 12    **Note**: This does not support line continuation. Long equations should be
 13    built by combining expressions using names short enough to do this on one
 14    line. The alternative is to use `equation_name = Eqn(long ...
 15    expressions ... with ... multiple ... lines)`.
 16
 17    **Note**: If the `equation_name` is omitted the equation will be formed,
 18    but it will not be assigned to a name that can be used to refer to it
 19    later. You may be able to access it through one of the special IPython
 20    underscore names. This is not recommended.
 21
 22    **THIS FUNCTION IS USED BY THE IPYTHON ENVIRONMENT TO PREPARSE THE INPUT
 23    BEFORE IT IS PASSED TO THE PYTHON INTERPRETER. IT IS NOT MEANT TO BE USED
 24    DIRECTLY BY A USER**
 25    """
 26    new_lines = []
 27    if isinstance(lines,str):
 28        lines = [lines]
 29    for k in lines:
 30        if '=@' in k:
 31            drop_comments = k.split('#')
 32            to_rephrase = ''
 33            if len(drop_comments) > 2:
 34                for i in range(len(drop_comments)-1):
 35                    to_rephrase += drop_comments[i]
 36            else:
 37                to_rephrase = drop_comments[0]
 38            linesplit = to_rephrase.split('=@')
 39            eqsplit = linesplit[1].split('=')
 40            if len(eqsplit)!=2:
 41                raise ValueError('The two sides of the equation must be' \
 42                                 ' separated by an \"=\" sign when using' \
 43                                 ' the \"=@\" special input method.')
 44            templine =''
 45            if eqsplit[0]!='' and eqsplit[1]!='':
 46                if eqsplit[1].endswith('\n'):
 47                    eqsplit[1] = eqsplit[1][:-1]
 48                if linesplit[0]!='':
 49                    templine = str(linesplit[0])+'= Eqn('+str(eqsplit[0])+',' \
 50                        ''+str(eqsplit[1])+')\n'
 51                else:
 52                    templine = 'Eqn('+str(eqsplit[0])+','+str(eqsplit[1])+')\n'
 53            new_lines.append(templine)
 54        else:
 55            new_lines.append(k)
 56    return new_lines
 57
 58
 59def toIntegerInSympyExpr(string):
 60    """ This function takes a string of valid Python and wraps integers within Sympy expressions
 61        in `sympy.Integer()` to make them Sympy integers rather than Python `Int()`. The
 62        advantage of this is that calculations with `Integer()` types can be exact. This function
 63        is careful not to wrap `Int()` types that are not part of Sympy expressions, making it
 64        possible for this functionality to exist with operations (e.g. array and numpy indexing)
 65        that are not compatible with the `Integer()` type.
 66    """
 67    from tokenize import generate_tokens, NEWLINE, OP, untokenize
 68    from io import StringIO
 69    ###
 70    # Internally used functions
 71    ###
 72    def isSympy(tokens, newSymObj):
 73        """ Checks list of tokens to see if it contains a Sympy Object
 74
 75        Parameters
 76        ==========
 77        tokens:list of tokens.
 78        newSymObj:list of string names of Sympy objects that have been declared
 79          in the current script/string being parsed.
 80        """
 81        from sympy import Basic
 82        from tokenize import NAME
 83        import __main__ as user_ns
 84        # print(dir(user_ns))
 85        sympy_obj = False
 86        for kind, string, start, end, line in tokens:
 87            if kind == NAME:
 88                # print('Checking: '+str(string))
 89                if hasattr(user_ns, string):
 90                    if isinstance(getattr(user_ns, string), Basic):
 91                        sympy_obj = True
 92                if string in newSymObj:
 93                    sympy_obj = True
 94        return sympy_obj
 95
 96    def toSympInteger(tokens):
 97        from tokenize import NUMBER, OP, NAME
 98        result = []
 99        for k in tokens:
100            if k[0] != NUMBER:
101                result.append((k[0], k[1]))
102            else:
103                if '.' in k[1] or 'j' in k[1].lower() or 'e' in k[1].lower():
104                    result.append((k[0], k[1]))
105                else:
106                    result.extend([
107                        (NAME, 'Integer'),
108                        (OP, '('),
109                        (NUMBER, k[1]),
110                        (OP, ')')
111                    ])
112        return result
113
114    def checkforSymObjDecl(token):
115        import re
116        from tokenize import NAME
117        syms = []
118        for kind, string, start, end, line in token:
119            if kind == NAME:
120                if string == 'var':
121                    match = re.search(r'\".*?\"|\'.*?\'', line)
122                    if (match):
123                        syms = match.group().replace('\"', '').replace('\'',
124                                                                   '').split(
125                        ' ')
126                if string == 'units':
127                    match = re.search(r'\".*?\"|\'.*?\'', line)
128                    if (match):
129                        syms = match.group().replace('\"', '').replace('\'',
130                                                                   '').split(
131                        ' ')
132                if string == 'symbols':
133                    parts = line.split('=')
134                    syms = parts[0].replace(' ', '').split(',')
135                if string == 'Symbol':
136                    parts = line.split('=')
137                    syms = parts[0].replace(' ', '').split(',')
138        return syms
139
140    ###
141    # The parsing and substitution.
142    ###
143    g = generate_tokens(StringIO(string).readline)
144    declaredSymObj = []
145    result = []
146    temptokens = []
147    openleft = 0
148    for k in g:
149        declaredSymObj.extend(checkforSymObjDecl([k]))
150        temptokens.append(k)
151        if k[0] == OP and k[1] == '(':
152            openleft += 1
153        if k[0] == OP and k[1] == ')':
154            openleft -= 1
155        if k[0] == NEWLINE and openleft == 0:
156            # This is where we check for sympy objects and replace int() with Integer()
157            hasSympyObj = isSympy(temptokens, declaredSymObj)
158            if hasSympyObj:
159                converted = toSympInteger(temptokens)
160                result.extend(converted)
161            else:
162                for j in temptokens:
163                    result.append((j[0],j[1]))
164            temptokens = []
165    return untokenize(result)
166
167def integers_as_exact(lines):
168    """This preparser uses `sympy.interactive.session.int_to_Integer` to
169    convert numbers without decimal points into sympy integers so that math
170    on them will be exact rather than defaulting to floating point. **This
171    should not be called directly by the user. It is plugged into the
172    IPython preparsing sequence when the feature is requested.** The default for
173    Algebra_with_sympy is to use this preparser. This can be turned on and
174    off using the Algebra_with_sympy functions:
175    * `set_integers_as_exact()`
176    * `unset_integers_as_exact()`
177    NOTE: This option does not work in plain vanilla Python sessions. You
178    must be running in an IPython environment (Jupyter, Notebook, Colab,
179    etc...).
180    """
181    #from sympy.interactive.session import int_to_Integer
182    string = ''
183    for k in lines:
184        string += k + '\n'
185    string = string[:-1] # remove the last '\n'
186    return toIntegerInSympyExpr(string)
187try:
188    from IPython import get_ipython
189    if get_ipython():
190        if hasattr(get_ipython(),'input_transformers_cleanup'):
191            get_ipython().input_transformers_post.\
192                append(algebra_with_sympy_preparser)
193        else:
194            import warnings
195            warnings.warn('Compact equation input unavailable.\nYou will have ' \
196                          'to use the form "eq1 = Eqn(lhs,rhs)" instead of ' \
197                          '"eq1=@lhs=rhs".\nIt appears you are running an ' \
198                          'outdated version of IPython.\nTo fix, update IPython ' \
199                          'using "pip install -U IPython".')
200except ModuleNotFoundError:
201    pass