Add files using upload-large-folder tool

ckpts/universal/global_step80/zero/14.attention.query_key_value.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c9af8e8e4828e2884a5b8332e7125200bb964a2c3170af01121b4356281a760
+size 50332749

ckpts/universal/global_step80/zero/16.mlp.dense_h_to_4h_swiglu.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb3b9bb294659ffafd8ad29200b8a25701570e07a2670f1624b07f888c32052e
+size 33555627

ckpts/universal/global_step80/zero/16.mlp.dense_h_to_4h_swiglu.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b1a1d1efe45051fc687a7953d3e1c72018f88f99aa282136d4e5290390c59fa6
+size 33555533

ckpts/universal/global_step80/zero/3.post_attention_layernorm.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee70579dfea323da963d6f373cf81636ad50eb365bd2bf510c48495409f54e34
+size 9372

ckpts/universal/global_step80/zero/3.post_attention_layernorm.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:66a22d1c829ecca9056579fdf60fbe4c2781339d5e78af142d745e95acdf8049
+size 9387

venv/lib/python3.10/site-packages/sympy/parsing/__init__.py

@@ -0,0 +1,4 @@
+"""Used for translating a string into a SymPy expression. """
+__all__ = ['parse_expr']
+
+from .sympy_parser import parse_expr

venv/lib/python3.10/site-packages/sympy/parsing/ast_parser.py

@@ -0,0 +1,79 @@
+"""
+This module implements the functionality to take any Python expression as a
+string and fix all numbers and other things before evaluating it,
+thus
+
+1/2
+
+returns
+
+Integer(1)/Integer(2)
+
+We use the ast module for this. It is well documented at docs.python.org.
+
+Some tips to understand how this works: use dump() to get a nice
+representation of any node. Then write a string of what you want to get,
+e.g. "Integer(1)", parse it, dump it and you'll see that you need to do
+"Call(Name('Integer', Load()), [node], [], None, None)". You do not need
+to bother with lineno and col_offset, just call fix_missing_locations()
+before returning the node.
+"""
+
+from sympy.core.basic import Basic
+from sympy.core.sympify import SympifyError
+
+from ast import parse, NodeTransformer, Call, Name, Load, \
+    fix_missing_locations, Str, Tuple
+
+class Transform(NodeTransformer):
+
+    def __init__(self, local_dict, global_dict):
+        NodeTransformer.__init__(self)
+        self.local_dict = local_dict
+        self.global_dict = global_dict
+
+    def visit_Constant(self, node):
+        if isinstance(node.value, int):
+            return fix_missing_locations(Call(func=Name('Integer', Load()),
+                    args=[node], keywords=[]))
+        elif isinstance(node.value, float):
+            return fix_missing_locations(Call(func=Name('Float', Load()),
+                    args=[node], keywords=[]))
+        return node
+
+    def visit_Name(self, node):
+        if node.id in self.local_dict:
+            return node
+        elif node.id in self.global_dict:
+            name_obj = self.global_dict[node.id]
+
+            if isinstance(name_obj, (Basic, type)) or callable(name_obj):
+                return node
+        elif node.id in ['True', 'False']:
+            return node
+        return fix_missing_locations(Call(func=Name('Symbol', Load()),
+                args=[Str(node.id)], keywords=[]))
+
+    def visit_Lambda(self, node):
+        args = [self.visit(arg) for arg in node.args.args]
+        body = self.visit(node.body)
+        n = Call(func=Name('Lambda', Load()),
+            args=[Tuple(args, Load()), body], keywords=[])
+        return fix_missing_locations(n)
+
+def parse_expr(s, local_dict):
+    """
+    Converts the string "s" to a SymPy expression, in local_dict.
+
+    It converts all numbers to Integers before feeding it to Python and
+    automatically creates Symbols.
+    """
+    global_dict = {}
+    exec('from sympy import *', global_dict)
+    try:
+        a = parse(s.strip(), mode="eval")
+    except SyntaxError:
+        raise SympifyError("Cannot parse %s." % repr(s))
+    a = Transform(local_dict, global_dict).visit(a)
+    e = compile(a, "<string>", "eval")
+    return eval(e, global_dict, local_dict)

venv/lib/python3.10/site-packages/sympy/parsing/autolev/Autolev.g4

@@ -0,0 +1,118 @@
+grammar Autolev;
+
+options {
+        language = Python3;
+}
+
+prog:   stat+;
+
+stat:   varDecl
+    |   functionCall
+    |   codeCommands
+    |   massDecl
+    |   inertiaDecl
+    |   assignment
+    |   settings
+    ;
+
+assignment:   vec equals expr #vecAssign
+          |   ID '[' index ']' equals expr #indexAssign
+          |   ID diff? equals expr #regularAssign;
+
+equals:   ('='|'+='|'-='|':='|'*='|'/='|'^=');
+
+index:   expr (',' expr)* ;
+
+diff:   ('\'')+;
+
+functionCall:   ID '(' (expr (',' expr)*)? ')'
+            |   (Mass|Inertia) '(' (ID (',' ID)*)? ')';
+
+varDecl:   varType varDecl2 (',' varDecl2)*;
+
+varType:   Newtonian|Frames|Bodies|Particles|Points|Constants
+       |   Specifieds|Imaginary|Variables ('\'')*|MotionVariables ('\'')*;
+
+varDecl2:   ID ('{' INT ',' INT '}')? (('{' INT ':' INT (',' INT ':' INT)* '}'))? ('{' INT '}')? ('+'|'-')? ('\'')* ('=' expr)?;
+
+ranges:   ('{' INT ':' INT (',' INT ':' INT)* '}');
+
+massDecl:   Mass massDecl2 (',' massDecl2)*;
+
+massDecl2:   ID '=' expr;
+
+inertiaDecl:   Inertia ID ('(' ID ')')? (',' expr)+;
+
+matrix:   '[' expr ((','|';') expr)* ']';
+matrixInOutput:   (ID (ID '=' (FLOAT|INT)?))|FLOAT|INT;
+
+codeCommands:   units
+            |   inputs
+            |   outputs
+            |   codegen
+            |   commands;
+
+settings:   ID (EXP|ID|FLOAT|INT)?;
+
+units:     UnitSystem ID (',' ID)*;
+inputs:    Input inputs2 (',' inputs2)*;
+id_diff:   ID diff?;
+inputs2:   id_diff '=' expr expr?;
+outputs:   Output outputs2 (',' outputs2)*;
+outputs2:  expr expr?;
+codegen:   ID functionCall ('['matrixInOutput (',' matrixInOutput)*']')? ID'.'ID;
+
+commands:  Save ID'.'ID
+        |  Encode ID (',' ID)*;
+
+vec:  ID ('>')+
+   |  '0>'
+   |  '1>>';
+
+expr:   expr '^'<assoc=right> expr  # Exponent
+    |   expr ('*'|'/') expr         # MulDiv
+    |   expr ('+'|'-') expr         # AddSub
+    |   EXP                         # exp
+    |   '-' expr                    # negativeOne
+    |   FLOAT                       # float
+    |   INT                         # int
+    |   ID('\'')*                   # id
+    |   vec                         # VectorOrDyadic
+    |   ID '['expr (',' expr)* ']'  # Indexing
+    |   functionCall                # function
+    |   matrix                      # matrices
+    |   '(' expr ')'                # parens
+    |   expr '=' expr               # idEqualsExpr
+    |   expr ':' expr               # colon
+    |   ID? ranges ('\'')*          # rangess
+    ;
+
+// These are to take care of the case insensitivity of Autolev.
+Mass: ('M'|'m')('A'|'a')('S'|'s')('S'|'s');
+Inertia: ('I'|'i')('N'|'n')('E'|'e')('R'|'r')('T'|'t')('I'|'i')('A'|'a');
+Input: ('I'|'i')('N'|'n')('P'|'p')('U'|'u')('T'|'t')('S'|'s')?;
+Output: ('O'|'o')('U'|'u')('T'|'t')('P'|'p')('U'|'u')('T'|'t');
+Save: ('S'|'s')('A'|'a')('V'|'v')('E'|'e');
+UnitSystem: ('U'|'u')('N'|'n')('I'|'i')('T'|'t')('S'|'s')('Y'|'y')('S'|'s')('T'|'t')('E'|'e')('M'|'m');
+Encode: ('E'|'e')('N'|'n')('C'|'c')('O'|'o')('D'|'d')('E'|'e');
+Newtonian: ('N'|'n')('E'|'e')('W'|'w')('T'|'t')('O'|'o')('N'|'n')('I'|'i')('A'|'a')('N'|'n');
+Frames: ('F'|'f')('R'|'r')('A'|'a')('M'|'m')('E'|'e')('S'|'s')?;
+Bodies: ('B'|'b')('O'|'o')('D'|'d')('I'|'i')('E'|'e')('S'|'s')?;
+Particles: ('P'|'p')('A'|'a')('R'|'r')('T'|'t')('I'|'i')('C'|'c')('L'|'l')('E'|'e')('S'|'s')?;
+Points: ('P'|'p')('O'|'o')('I'|'i')('N'|'n')('T'|'t')('S'|'s')?;
+Constants: ('C'|'c')('O'|'o')('N'|'n')('S'|'s')('T'|'t')('A'|'a')('N'|'n')('T'|'t')('S'|'s')?;
+Specifieds: ('S'|'s')('P'|'p')('E'|'e')('C'|'c')('I'|'i')('F'|'f')('I'|'i')('E'|'e')('D'|'d')('S'|'s')?;
+Imaginary: ('I'|'i')('M'|'m')('A'|'a')('G'|'g')('I'|'i')('N'|'n')('A'|'a')('R'|'r')('Y'|'y');
+Variables: ('V'|'v')('A'|'a')('R'|'r')('I'|'i')('A'|'a')('B'|'b')('L'|'l')('E'|'e')('S'|'s')?;
+MotionVariables: ('M'|'m')('O'|'o')('T'|'t')('I'|'i')('O'|'o')('N'|'n')('V'|'v')('A'|'a')('R'|'r')('I'|'i')('A'|'a')('B'|'b')('L'|'l')('E'|'e')('S'|'s')?;
+
+fragment DIFF:   ('\'')*;
+fragment DIGIT:  [0-9];
+INT:   [0-9]+ ;         // match integers
+FLOAT:  DIGIT+ '.' DIGIT*
+     |  '.' DIGIT+;
+EXP:   FLOAT 'E' INT
+|      FLOAT 'E' '-' INT;
+LINE_COMMENT : '%' .*? '\r'? '\n' -> skip ;
+ID:   [a-zA-Z][a-zA-Z0-9_]*;
+WS:   [ \t\r\n&]+ -> skip ; // toss out whitespace

venv/lib/python3.10/site-packages/sympy/parsing/autolev/__init__.py

@@ -0,0 +1,97 @@
+from sympy.external import import_module
+from sympy.utilities.decorator import doctest_depends_on
+
+@doctest_depends_on(modules=('antlr4',))
+def parse_autolev(autolev_code, include_numeric=False):
+    """Parses Autolev code (version 4.1) to SymPy code.
+
+    Parameters
+    =========
+    autolev_code : Can be an str or any object with a readlines() method (such as a file handle or StringIO).
+    include_numeric : boolean, optional
+        If True NumPy, PyDy, or other numeric code is included for numeric evaluation lines in the Autolev code.
+
+    Returns
+    =======
+    sympy_code : str
+        Equivalent SymPy and/or numpy/pydy code as the input code.
+
+
+    Example (Double Pendulum)
+    =========================
+    >>> my_al_text = ("MOTIONVARIABLES' Q{2}', U{2}'",
+    ... "CONSTANTS L,M,G",
+    ... "NEWTONIAN N",
+    ... "FRAMES A,B",
+    ... "SIMPROT(N, A, 3, Q1)",
+    ... "SIMPROT(N, B, 3, Q2)",
+    ... "W_A_N>=U1*N3>",
+    ... "W_B_N>=U2*N3>",
+    ... "POINT O",
+    ... "PARTICLES P,R",
+    ... "P_O_P> = L*A1>",
+    ... "P_P_R> = L*B1>",
+    ... "V_O_N> = 0>",
+    ... "V2PTS(N, A, O, P)",
+    ... "V2PTS(N, B, P, R)",
+    ... "MASS P=M, R=M",
+    ... "Q1' = U1",
+    ... "Q2' = U2",
+    ... "GRAVITY(G*N1>)",
+    ... "ZERO = FR() + FRSTAR()",
+    ... "KANE()",
+    ... "INPUT M=1,G=9.81,L=1",
+    ... "INPUT Q1=.1,Q2=.2,U1=0,U2=0",
+    ... "INPUT TFINAL=10, INTEGSTP=.01",
+    ... "CODE DYNAMICS() some_filename.c")
+    >>> my_al_text = '\\n'.join(my_al_text)
+    >>> from sympy.parsing.autolev import parse_autolev
+    >>> print(parse_autolev(my_al_text, include_numeric=True))
+    import sympy.physics.mechanics as _me
+    import sympy as _sm
+    import math as m
+    import numpy as _np
+    <BLANKLINE>
+    q1, q2, u1, u2 = _me.dynamicsymbols('q1 q2 u1 u2')
+    q1_d, q2_d, u1_d, u2_d = _me.dynamicsymbols('q1_ q2_ u1_ u2_', 1)
+    l, m, g = _sm.symbols('l m g', real=True)
+    frame_n = _me.ReferenceFrame('n')
+    frame_a = _me.ReferenceFrame('a')
+    frame_b = _me.ReferenceFrame('b')
+    frame_a.orient(frame_n, 'Axis', [q1, frame_n.z])
+    frame_b.orient(frame_n, 'Axis', [q2, frame_n.z])
+    frame_a.set_ang_vel(frame_n, u1*frame_n.z)
+    frame_b.set_ang_vel(frame_n, u2*frame_n.z)
+    point_o = _me.Point('o')
+    particle_p = _me.Particle('p', _me.Point('p_pt'), _sm.Symbol('m'))
+    particle_r = _me.Particle('r', _me.Point('r_pt'), _sm.Symbol('m'))
+    particle_p.point.set_pos(point_o, l*frame_a.x)
+    particle_r.point.set_pos(particle_p.point, l*frame_b.x)
+    point_o.set_vel(frame_n, 0)
+    particle_p.point.v2pt_theory(point_o,frame_n,frame_a)
+    particle_r.point.v2pt_theory(particle_p.point,frame_n,frame_b)
+    particle_p.mass = m
+    particle_r.mass = m
+    force_p = particle_p.mass*(g*frame_n.x)
+    force_r = particle_r.mass*(g*frame_n.x)
+    kd_eqs = [q1_d - u1, q2_d - u2]
+    forceList = [(particle_p.point,particle_p.mass*(g*frame_n.x)), (particle_r.point,particle_r.mass*(g*frame_n.x))]
+    kane = _me.KanesMethod(frame_n, q_ind=[q1,q2], u_ind=[u1, u2], kd_eqs = kd_eqs)
+    fr, frstar = kane.kanes_equations([particle_p, particle_r], forceList)
+    zero = fr+frstar
+    from pydy.system import System
+    sys = System(kane, constants = {l:1, m:1, g:9.81},
+    specifieds={},
+    initial_conditions={q1:.1, q2:.2, u1:0, u2:0},
+    times = _np.linspace(0.0, 10, 10/.01))
+    <BLANKLINE>
+    y=sys.integrate()
+    <BLANKLINE>
+    """
+
+    _autolev = import_module(
+        'sympy.parsing.autolev._parse_autolev_antlr',
+        import_kwargs={'fromlist': ['X']})
+
+    if _autolev is not None:
+        return _autolev.parse_autolev(autolev_code, include_numeric)

venv/lib/python3.10/site-packages/sympy/parsing/autolev/_build_autolev_antlr.py

@@ -0,0 +1,86 @@
+import os
+import subprocess
+import glob
+
+from sympy.utilities.misc import debug
+
+here = os.path.dirname(__file__)
+grammar_file = os.path.abspath(os.path.join(here, "Autolev.g4"))
+dir_autolev_antlr = os.path.join(here, "_antlr")
+
+header = '''\
+# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
+#
+# Generated with antlr4
+#    antlr4 is licensed under the BSD-3-Clause License
+#    https://github.com/antlr/antlr4/blob/master/LICENSE.txt
+'''
+
+
+def check_antlr_version():
+    debug("Checking antlr4 version...")
+
+    try:
+        debug(subprocess.check_output(["antlr4"])
+              .decode('utf-8').split("\n")[0])
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        debug("The 'antlr4' command line tool is not installed, "
+              "or not on your PATH.\n"
+              "> Please refer to the README.md file for more information.")
+        return False
+
+
+def build_parser(output_dir=dir_autolev_antlr):
+    check_antlr_version()
+
+    debug("Updating ANTLR-generated code in {}".format(output_dir))
+
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    with open(os.path.join(output_dir, "__init__.py"), "w+") as fp:
+        fp.write(header)
+
+    args = [
+        "antlr4",
+        grammar_file,
+        "-o", output_dir,
+        "-no-visitor",
+    ]
+
+    debug("Running code generation...\n\t$ {}".format(" ".join(args)))
+    subprocess.check_output(args, cwd=output_dir)
+
+    debug("Applying headers, removing unnecessary files and renaming...")
+    # Handle case insensitive file systems. If the files are already
+    # generated, they will be written to autolev* but Autolev*.* won't match them.
+    for path in (glob.glob(os.path.join(output_dir, "Autolev*.*")) or
+        glob.glob(os.path.join(output_dir, "autolev*.*"))):
+
+        # Remove files ending in .interp or .tokens as they are not needed.
+        if not path.endswith(".py"):
+            os.unlink(path)
+            continue
+
+        new_path = os.path.join(output_dir, os.path.basename(path).lower())
+        with open(path, 'r') as f:
+            lines = [line.rstrip().replace('AutolevParser import', 'autolevparser import') +'\n'
+                     for line in f.readlines()]
+
+        os.unlink(path)
+
+        with open(new_path, "w") as out_file:
+            offset = 0
+            while lines[offset].startswith('#'):
+                offset += 1
+            out_file.write(header)
+            out_file.writelines(lines[offset:])
+
+        debug("\t{}".format(new_path))
+
+    return True
+
+
+if __name__ == "__main__":
+    build_parser()

venv/lib/python3.10/site-packages/sympy/parsing/autolev/_parse_autolev_antlr.py

@@ -0,0 +1,38 @@
+from importlib.metadata import version
+from sympy.external import import_module
+
+
+autolevparser = import_module('sympy.parsing.autolev._antlr.autolevparser',
+                              import_kwargs={'fromlist': ['AutolevParser']})
+autolevlexer = import_module('sympy.parsing.autolev._antlr.autolevlexer',
+                             import_kwargs={'fromlist': ['AutolevLexer']})
+autolevlistener = import_module('sympy.parsing.autolev._antlr.autolevlistener',
+                                import_kwargs={'fromlist': ['AutolevListener']})
+
+AutolevParser = getattr(autolevparser, 'AutolevParser', None)
+AutolevLexer = getattr(autolevlexer, 'AutolevLexer', None)
+AutolevListener = getattr(autolevlistener, 'AutolevListener', None)
+
+
+def parse_autolev(autolev_code, include_numeric):
+    antlr4 = import_module('antlr4')
+    if not antlr4 or not version('antlr4-python3-runtime').startswith('4.11'):
+        raise ImportError("Autolev parsing requires the antlr4 Python package,"
+                          " provided by pip (antlr4-python3-runtime)"
+                          " conda (antlr-python-runtime), version 4.11")
+    try:
+        l = autolev_code.readlines()
+        input_stream = antlr4.InputStream("".join(l))
+    except Exception:
+        input_stream = antlr4.InputStream(autolev_code)
+
+    if AutolevListener:
+        from ._listener_autolev_antlr import MyListener
+        lexer = AutolevLexer(input_stream)
+        token_stream = antlr4.CommonTokenStream(lexer)
+        parser = AutolevParser(token_stream)
+        tree = parser.prog()
+        my_listener = MyListener(include_numeric)
+        walker = antlr4.ParseTreeWalker()
+        walker.walk(my_listener, tree)
+        return "".join(my_listener.output_code)

venv/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest12.al

@@ -0,0 +1,7 @@
+VARIABLES X,Y
+CONSTANTS A,B,R
+EQN[1] = A*X^3+B*Y^2-R
+EQN[2] = A*SIN(X)^2 + B*COS(2*Y) - R^2
+INPUT A=2.0, B=3.0, R=1.0
+INPUT X = 30 DEG, Y = 3.14
+CODE NONLINEAR(EQN,X,Y) some_filename.c

venv/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest12.py

@@ -0,0 +1,14 @@
+import sympy.physics.mechanics as _me
+import sympy as _sm
+import math as m
+import numpy as _np
+
+x, y = _me.dynamicsymbols('x y')
+a, b, r = _sm.symbols('a b r', real=True)
+eqn = _sm.Matrix([[0]])
+eqn[0] = a*x**3+b*y**2-r
+eqn = eqn.row_insert(eqn.shape[0], _sm.Matrix([[0]]))
+eqn[eqn.shape[0]-1] = a*_sm.sin(x)**2+b*_sm.cos(2*y)-r**2
+matrix_list = []
+for i in eqn:matrix_list.append(i.subs({a:2.0, b:3.0, r:1.0}))
+print(_sm.nsolve(matrix_list,(x,y),(_np.deg2rad(30),3.14)))

venv/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest4.al

@@ -0,0 +1,20 @@
+% ruletest4.al
+
+FRAMES A, B
+MOTIONVARIABLES Q{3}
+SIMPROT(A, B, 1, Q3)
+DCM = A_B
+M = DCM*3 - A_B
+
+VARIABLES R
+CIRCLE_AREA = PI*R^2
+
+VARIABLES U, A
+VARIABLES X, Y
+S = U*T - 1/2*A*T^2
+
+EXPR1 = 2*A*0.5 - 1.25 + 0.25
+EXPR2 = -X^2 + Y^2 + 0.25*(X+Y)^2
+EXPR3 = 0.5E-10
+
+DYADIC>> = A1>*A1> + A2>*A2> + A3>*A3>

venv/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest5.al

@@ -0,0 +1,32 @@
+% ruletest5.al
+VARIABLES X', Y'
+
+E1 = (X+Y)^2 + (X-Y)^3
+E2 = (X-Y)^2
+E3 = X^2 + Y^2 + 2*X*Y
+
+M1 = [E1;E2]
+M2 = [(X+Y)^2,(X-Y)^2]
+M3 = M1 + [X;Y]
+
+AM = EXPAND(M1)
+CM = EXPAND([(X+Y)^2,(X-Y)^2])
+EM = EXPAND(M1 + [X;Y])
+F = EXPAND(E1)
+G = EXPAND(E2)
+
+A = FACTOR(E3, X)
+BM = FACTOR(M1, X)
+CM = FACTOR(M1 + [X;Y], X)
+
+A = D(E3, X)
+B = D(E3, Y)
+CM = D(M2, X)
+DM = D(M1 + [X;Y], X)
+FRAMES A, B
+A_B = [1,0,0;1,0,0;1,0,0]
+V1> = X*A1> + Y*A2> + X*Y*A3>
+E> = D(V1>, X, B)
+FM = DT(M1)
+GM = DT([(X+Y)^2,(X-Y)^2])
+H> = DT(V1>, B)

venv/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest5.py

@@ -0,0 +1,33 @@
+import sympy.physics.mechanics as _me
+import sympy as _sm
+import math as m
+import numpy as _np
+
+x, y = _me.dynamicsymbols('x y')
+x_d, y_d = _me.dynamicsymbols('x_ y_', 1)
+e1 = (x+y)**2+(x-y)**3
+e2 = (x-y)**2
+e3 = x**2+y**2+2*x*y
+m1 = _sm.Matrix([e1,e2]).reshape(2, 1)
+m2 = _sm.Matrix([(x+y)**2,(x-y)**2]).reshape(1, 2)
+m3 = m1+_sm.Matrix([x,y]).reshape(2, 1)
+am = _sm.Matrix([i.expand() for i in m1]).reshape((m1).shape[0], (m1).shape[1])
+cm = _sm.Matrix([i.expand() for i in _sm.Matrix([(x+y)**2,(x-y)**2]).reshape(1, 2)]).reshape((_sm.Matrix([(x+y)**2,(x-y)**2]).reshape(1, 2)).shape[0], (_sm.Matrix([(x+y)**2,(x-y)**2]).reshape(1, 2)).shape[1])
+em = _sm.Matrix([i.expand() for i in m1+_sm.Matrix([x,y]).reshape(2, 1)]).reshape((m1+_sm.Matrix([x,y]).reshape(2, 1)).shape[0], (m1+_sm.Matrix([x,y]).reshape(2, 1)).shape[1])
+f = (e1).expand()
+g = (e2).expand()
+a = _sm.factor((e3), x)
+bm = _sm.Matrix([_sm.factor(i, x) for i in m1]).reshape((m1).shape[0], (m1).shape[1])
+cm = _sm.Matrix([_sm.factor(i, x) for i in m1+_sm.Matrix([x,y]).reshape(2, 1)]).reshape((m1+_sm.Matrix([x,y]).reshape(2, 1)).shape[0], (m1+_sm.Matrix([x,y]).reshape(2, 1)).shape[1])
+a = (e3).diff(x)
+b = (e3).diff(y)
+cm = _sm.Matrix([i.diff(x) for i in m2]).reshape((m2).shape[0], (m2).shape[1])
+dm = _sm.Matrix([i.diff(x) for i in m1+_sm.Matrix([x,y]).reshape(2, 1)]).reshape((m1+_sm.Matrix([x,y]).reshape(2, 1)).shape[0], (m1+_sm.Matrix([x,y]).reshape(2, 1)).shape[1])
+frame_a = _me.ReferenceFrame('a')
+frame_b = _me.ReferenceFrame('b')
+frame_b.orient(frame_a, 'DCM', _sm.Matrix([1,0,0,1,0,0,1,0,0]).reshape(3, 3))
+v1 = x*frame_a.x+y*frame_a.y+x*y*frame_a.z
+e = (v1).diff(x, frame_b)
+fm = _sm.Matrix([i.diff(_sm.Symbol('t')) for i in m1]).reshape((m1).shape[0], (m1).shape[1])
+gm = _sm.Matrix([i.diff(_sm.Symbol('t')) for i in _sm.Matrix([(x+y)**2,(x-y)**2]).reshape(1, 2)]).reshape((_sm.Matrix([(x+y)**2,(x-y)**2]).reshape(1, 2)).shape[0], (_sm.Matrix([(x+y)**2,(x-y)**2]).reshape(1, 2)).shape[1])
+h = (v1).dt(frame_b)

venv/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest6.al

@@ -0,0 +1,41 @@
+% ruletest6.al
+VARIABLES Q{2}
+VARIABLES X,Y,Z
+Q1 = X^2 + Y^2
+Q2 = X-Y
+E = Q1 + Q2
+A = EXPLICIT(E)
+E2 = COS(X)
+E3 = COS(X*Y)
+A = TAYLOR(E2, 0:2, X=0)
+B = TAYLOR(E3, 0:2, X=0, Y=0)
+
+E = EXPAND((X+Y)^2)
+A = EVALUATE(E, X=1, Y=Z)
+BM = EVALUATE([E;2*E], X=1, Y=Z)
+
+E = Q1 + Q2
+A = EVALUATE(E, X=2, Y=Z^2)
+
+CONSTANTS J,K,L
+P1 = POLYNOMIAL([J,K,L],X)
+P2 = POLYNOMIAL(J*X+K,X,1)
+
+ROOT1 = ROOTS(P1, X, 2)
+ROOT2 = ROOTS([1;2;3])
+
+M = [1,2,3,4;5,6,7,8;9,10,11,12;13,14,15,16]
+
+AM = TRANSPOSE(M) + M
+BM = EIG(M)
+C1 = DIAGMAT(4, 1)
+C2 = DIAGMAT(3, 4, 2)
+DM = INV(M+C1)
+E = DET(M+C1) + TRACE([1,0;0,1])
+F = ELEMENT(M, 2, 3)
+
+A = COLS(M)
+BM = COLS(M, 1)
+CM = COLS(M, 1, 2:4, 3)
+DM = ROWS(M, 1)
+EM = ROWS(M, 1, 2:4, 3)

venv/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest6.py

@@ -0,0 +1,36 @@
+import sympy.physics.mechanics as _me
+import sympy as _sm
+import math as m
+import numpy as _np
+
+q1, q2 = _me.dynamicsymbols('q1 q2')
+x, y, z = _me.dynamicsymbols('x y z')
+e = q1+q2
+a = (e).subs({q1:x**2+y**2, q2:x-y})
+e2 = _sm.cos(x)
+e3 = _sm.cos(x*y)
+a = (e2).series(x, 0, 2).removeO()
+b = (e3).series(x, 0, 2).removeO().series(y, 0, 2).removeO()
+e = ((x+y)**2).expand()
+a = (e).subs({q1:x**2+y**2,q2:x-y}).subs({x:1,y:z})
+bm = _sm.Matrix([i.subs({x:1,y:z}) for i in _sm.Matrix([e,2*e]).reshape(2, 1)]).reshape((_sm.Matrix([e,2*e]).reshape(2, 1)).shape[0], (_sm.Matrix([e,2*e]).reshape(2, 1)).shape[1])
+e = q1+q2
+a = (e).subs({q1:x**2+y**2,q2:x-y}).subs({x:2,y:z**2})
+j, k, l = _sm.symbols('j k l', real=True)
+p1 = _sm.Poly(_sm.Matrix([j,k,l]).reshape(1, 3), x)
+p2 = _sm.Poly(j*x+k, x)
+root1 = [i.evalf() for i in _sm.solve(p1, x)]
+root2 = [i.evalf() for i in _sm.solve(_sm.Poly(_sm.Matrix([1,2,3]).reshape(3, 1), x),x)]
+m = _sm.Matrix([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]).reshape(4, 4)
+am = (m).T+m
+bm = _sm.Matrix([i.evalf() for i in (m).eigenvals().keys()])
+c1 = _sm.diag(1,1,1,1)
+c2 = _sm.Matrix([2 if i==j else 0 for i in range(3) for j in range(4)]).reshape(3, 4)
+dm = (m+c1)**(-1)
+e = (m+c1).det()+(_sm.Matrix([1,0,0,1]).reshape(2, 2)).trace()
+f = (m)[1,2]
+a = (m).cols
+bm = (m).col(0)
+cm = _sm.Matrix([(m).T.row(0),(m).T.row(1),(m).T.row(2),(m).T.row(3),(m).T.row(2)])
+dm = (m).row(0)
+em = _sm.Matrix([(m).row(0),(m).row(1),(m).row(2),(m).row(3),(m).row(2)])

venv/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest7.py

@@ -0,0 +1,35 @@
+import sympy.physics.mechanics as _me
+import sympy as _sm
+import math as m
+import numpy as _np
+
+x, y = _me.dynamicsymbols('x y')
+x_d, y_d = _me.dynamicsymbols('x_ y_', 1)
+e = _sm.cos(x)+_sm.sin(x)+_sm.tan(x)+_sm.cosh(x)+_sm.sinh(x)+_sm.tanh(x)+_sm.acos(x)+_sm.asin(x)+_sm.atan(x)+_sm.log(x)+_sm.exp(x)+_sm.sqrt(x)+_sm.factorial(x)+_sm.ceiling(x)+_sm.floor(x)+_sm.sign(x)
+e = (x)**2+_sm.log(x, 10)
+a = _sm.Abs(-1*1)+int(1.5)+round(1.9)
+e1 = 2*x+3*y
+e2 = x+y
+am = _sm.Matrix([e1.expand().coeff(x), e1.expand().coeff(y), e2.expand().coeff(x), e2.expand().coeff(y)]).reshape(2, 2)
+b = (e1).expand().coeff(x)
+c = (e2).expand().coeff(y)
+d1 = (e1).collect(x).coeff(x,0)
+d2 = (e1).collect(x).coeff(x,1)
+fm = _sm.Matrix([i.collect(x)for i in _sm.Matrix([e1,e2]).reshape(1, 2)]).reshape((_sm.Matrix([e1,e2]).reshape(1, 2)).shape[0], (_sm.Matrix([e1,e2]).reshape(1, 2)).shape[1])
+f = (e1).collect(y)
+g = (e1).subs({x:2*x})
+gm = _sm.Matrix([i.subs({x:3}) for i in _sm.Matrix([e1,e2]).reshape(2, 1)]).reshape((_sm.Matrix([e1,e2]).reshape(2, 1)).shape[0], (_sm.Matrix([e1,e2]).reshape(2, 1)).shape[1])
+frame_a = _me.ReferenceFrame('a')
+frame_b = _me.ReferenceFrame('b')
+theta = _me.dynamicsymbols('theta')
+frame_b.orient(frame_a, 'Axis', [theta, frame_a.z])
+v1 = 2*frame_a.x-3*frame_a.y+frame_a.z
+v2 = frame_b.x+frame_b.y+frame_b.z
+a = _me.dot(v1, v2)
+bm = _sm.Matrix([_me.dot(v1, v2),_me.dot(v1, 2*v2)]).reshape(2, 1)
+c = _me.cross(v1, v2)
+d = 2*v1.magnitude()+3*v1.magnitude()
+dyadic = _me.outer(3*frame_a.x, frame_a.x)+_me.outer(frame_a.y, frame_a.y)+_me.outer(2*frame_a.z, frame_a.z)
+am = (dyadic).to_matrix(frame_b)
+m = _sm.Matrix([1,2,3]).reshape(3, 1)
+v = m[0]*frame_a.x +m[1]*frame_a.y +m[2]*frame_a.z

venv/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest8.py

@@ -0,0 +1,49 @@
+import sympy.physics.mechanics as _me
+import sympy as _sm
+import math as m
+import numpy as _np
+
+frame_a = _me.ReferenceFrame('a')
+c1, c2, c3 = _sm.symbols('c1 c2 c3', real=True)
+a = _me.inertia(frame_a, 1, 1, 1)
+particle_p1 = _me.Particle('p1', _me.Point('p1_pt'), _sm.Symbol('m'))
+particle_p2 = _me.Particle('p2', _me.Point('p2_pt'), _sm.Symbol('m'))
+body_r_cm = _me.Point('r_cm')
+body_r_f = _me.ReferenceFrame('r_f')
+body_r = _me.RigidBody('r', body_r_cm, body_r_f, _sm.symbols('m'), (_me.outer(body_r_f.x,body_r_f.x),body_r_cm))
+frame_a.orient(body_r_f, 'DCM', _sm.Matrix([1,1,1,1,1,0,0,0,1]).reshape(3, 3))
+point_o = _me.Point('o')
+m1 = _sm.symbols('m1')
+particle_p1.mass = m1
+m2 = _sm.symbols('m2')
+particle_p2.mass = m2
+mr = _sm.symbols('mr')
+body_r.mass = mr
+i1 = _sm.symbols('i1')
+i2 = _sm.symbols('i2')
+i3 = _sm.symbols('i3')
+body_r.inertia = (_me.inertia(body_r_f, i1, i2, i3, 0, 0, 0), body_r_cm)
+point_o.set_pos(particle_p1.point, c1*frame_a.x)
+point_o.set_pos(particle_p2.point, c2*frame_a.y)
+point_o.set_pos(body_r_cm, c3*frame_a.z)
+a = _me.inertia_of_point_mass(particle_p1.mass, particle_p1.point.pos_from(point_o), frame_a)
+a = _me.inertia_of_point_mass(particle_p2.mass, particle_p2.point.pos_from(point_o), frame_a)
+a = body_r.inertia[0] + _me.inertia_of_point_mass(body_r.mass, body_r.masscenter.pos_from(point_o), frame_a)
+a = _me.inertia_of_point_mass(particle_p1.mass, particle_p1.point.pos_from(point_o), frame_a) + _me.inertia_of_point_mass(particle_p2.mass, particle_p2.point.pos_from(point_o), frame_a) + body_r.inertia[0] + _me.inertia_of_point_mass(body_r.mass, body_r.masscenter.pos_from(point_o), frame_a)
+a = _me.inertia_of_point_mass(particle_p1.mass, particle_p1.point.pos_from(point_o), frame_a) + body_r.inertia[0] + _me.inertia_of_point_mass(body_r.mass, body_r.masscenter.pos_from(point_o), frame_a)
+a = body_r.inertia[0] + _me.inertia_of_point_mass(body_r.mass, body_r.masscenter.pos_from(point_o), frame_a)
+a = body_r.inertia[0]
+particle_p2.point.set_pos(particle_p1.point, c1*frame_a.x+c2*frame_a.y)
+body_r_cm.set_pos(particle_p1.point, c3*frame_a.x)
+body_r_cm.set_pos(particle_p2.point, c3*frame_a.y)
+b = _me.functions.center_of_mass(point_o,particle_p1, particle_p2, body_r)
+b = _me.functions.center_of_mass(point_o,particle_p1, body_r)
+b = _me.functions.center_of_mass(particle_p1.point,particle_p1, particle_p2, body_r)
+u1, u2, u3 = _me.dynamicsymbols('u1 u2 u3')
+v = u1*frame_a.x+u2*frame_a.y+u3*frame_a.z
+u = (v+c1*frame_a.x).normalize()
+particle_p1.point.set_vel(frame_a, u1*frame_a.x)
+a = particle_p1.point.partial_velocity(frame_a, u1)
+m = particle_p1.mass+body_r.mass
+m = particle_p2.mass
+m = particle_p1.mass+particle_p2.mass+body_r.mass

venv/lib/python3.10/site-packages/sympy/parsing/c/__init__.py

@@ -0,0 +1 @@
+"""Used for translating C source code into a SymPy expression"""

venv/lib/python3.10/site-packages/sympy/parsing/c/c_parser.py

@@ -0,0 +1,1090 @@
+from sympy.external import import_module
+import os
+
+cin = import_module('clang.cindex', import_kwargs = {'fromlist': ['cindex']})
+
+"""
+This module contains all the necessary Classes and Function used to Parse C and
+C++ code into SymPy expression
+The module serves as a backend for SymPyExpression to parse C code
+It is also dependent on Clang's AST and SymPy's Codegen AST.
+The module only supports the features currently supported by the Clang and
+codegen AST which will be updated as the development of codegen AST and this
+module progresses.
+You might find unexpected bugs and exceptions while using the module, feel free
+to report them to the SymPy Issue Tracker
+
+Features Supported
+==================
+
+- Variable Declarations (integers and reals)
+- Assignment (using integer & floating literal and function calls)
+- Function Definitions and Declaration
+- Function Calls
+- Compound statements, Return statements
+
+Notes
+=====
+
+The module is dependent on an external dependency which needs to be installed
+to use the features of this module.
+
+Clang: The C and C++ compiler which is used to extract an AST from the provided
+C source code.
+
+References
+==========
+
+.. [1] https://github.com/sympy/sympy/issues
+.. [2] https://clang.llvm.org/docs/
+.. [3] https://clang.llvm.org/docs/IntroductionToTheClangAST.html
+
+"""
+
+if cin:
+    from sympy.codegen.ast import (Variable, Integer, Float,
+        FunctionPrototype, FunctionDefinition, FunctionCall,
+        none, Return, Assignment, intc, int8, int16, int64,
+        uint8, uint16, uint32, uint64, float32, float64, float80,
+        aug_assign, bool_, While, CodeBlock)
+    from sympy.codegen.cnodes import (PreDecrement, PostDecrement,
+        PreIncrement, PostIncrement)
+    from sympy.core import Add, Mod, Mul, Pow, Rel
+    from sympy.logic.boolalg import And, as_Boolean, Not, Or
+    from sympy.core.symbol import Symbol
+    from sympy.core.sympify import sympify
+    from sympy.logic.boolalg import (false, true)
+    import sys
+    import tempfile
+
+    class BaseParser:
+        """Base Class for the C parser"""
+
+        def __init__(self):
+            """Initializes the Base parser creating a Clang AST index"""
+            self.index = cin.Index.create()
+
+        def diagnostics(self, out):
+            """Diagostics function for the Clang AST"""
+            for diag in self.tu.diagnostics:
+                print('%s %s (line %s, col %s) %s' % (
+                        {
+                            4: 'FATAL',
+                            3: 'ERROR',
+                            2: 'WARNING',
+                            1: 'NOTE',
+                            0: 'IGNORED',
+                        }[diag.severity],
+                        diag.location.file,
+                        diag.location.line,
+                        diag.location.column,
+                        diag.spelling
+                    ), file=out)
+
+    class CCodeConverter(BaseParser):
+        """The Code Convereter for Clang AST
+
+        The converter object takes the C source code or file as input and
+        converts them to SymPy Expressions.
+        """
+
+        def __init__(self):
+            """Initializes the code converter"""
+            super().__init__()
+            self._py_nodes = []
+            self._data_types = {
+                "void": {
+                    cin.TypeKind.VOID: none
+                },
+                "bool": {
+                    cin.TypeKind.BOOL: bool_
+                },
+                "int": {
+                    cin.TypeKind.SCHAR: int8,
+                    cin.TypeKind.SHORT: int16,
+                    cin.TypeKind.INT: intc,
+                    cin.TypeKind.LONG: int64,
+                    cin.TypeKind.UCHAR: uint8,
+                    cin.TypeKind.USHORT: uint16,
+                    cin.TypeKind.UINT: uint32,
+                    cin.TypeKind.ULONG: uint64
+                },
+                "float": {
+                    cin.TypeKind.FLOAT: float32,
+                    cin.TypeKind.DOUBLE: float64,
+                    cin.TypeKind.LONGDOUBLE: float80
+                }
+            }
+
+        def parse(self, filenames, flags):
+            """Function to parse a file with C source code
+
+            It takes the filename as an attribute and creates a Clang AST
+            Translation Unit parsing the file.
+            Then the transformation function is called on the translation unit,
+            whose reults are collected into a list which is returned by the
+            function.
+
+            Parameters
+            ==========
+
+            filenames : string
+                Path to the C file to be parsed
+
+            flags: list
+                Arguments to be passed to Clang while parsing the C code
+
+            Returns
+            =======
+
+            py_nodes: list
+                A list of SymPy AST nodes
+
+            """
+            filename = os.path.abspath(filenames)
+            self.tu = self.index.parse(
+                filename,
+                args=flags,
+                options=cin.TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD
+            )
+            for child in self.tu.cursor.get_children():
+                if child.kind == cin.CursorKind.VAR_DECL:
+                    self._py_nodes.append(self.transform(child))
+                elif (child.kind == cin.CursorKind.FUNCTION_DECL):
+                    self._py_nodes.append(self.transform(child))
+                else:
+                    pass
+            return self._py_nodes
+
+        def parse_str(self, source, flags):
+            """Function to parse a string with C source code
+
+            It takes the source code as an attribute, stores it in a temporary
+            file and creates a Clang AST Translation Unit parsing the file.
+            Then the transformation function is called on the translation unit,
+            whose reults are collected into a list which is returned by the
+            function.
+
+            Parameters
+            ==========
+
+            source : string
+                Path to the C file to be parsed
+
+            flags: list
+                Arguments to be passed to Clang while parsing the C code
+
+            Returns
+            =======
+
+            py_nodes: list
+                A list of SymPy AST nodes
+
+            """
+            file = tempfile.NamedTemporaryFile(mode = 'w+', suffix = '.cpp')
+            file.write(source)
+            file.seek(0)
+            self.tu = self.index.parse(
+                file.name,
+                args=flags,
+                options=cin.TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD
+            )
+            file.close()
+            for child in self.tu.cursor.get_children():
+                if child.kind == cin.CursorKind.VAR_DECL:
+                    self._py_nodes.append(self.transform(child))
+                elif (child.kind == cin.CursorKind.FUNCTION_DECL):
+                    self._py_nodes.append(self.transform(child))
+                else:
+                    pass
+            return self._py_nodes
+
+        def transform(self, node):
+            """Transformation Function for Clang AST nodes
+
+            It determines the kind of node and calls the respective
+            transformation function for that node.
+
+            Raises
+            ======
+
+            NotImplementedError : if the transformation for the provided node
+            is not implemented
+
+            """
+            try:
+                handler = getattr(self, 'transform_%s' % node.kind.name.lower())
+            except AttributeError:
+                print(
+                    "Ignoring node of type %s (%s)" % (
+                        node.kind,
+                        ' '.join(
+                            t.spelling for t in node.get_tokens())
+                        ),
+                    file=sys.stderr
+                )
+                handler = None
+            if handler:
+                result = handler(node)
+                return result
+
+        def transform_var_decl(self, node):
+            """Transformation Function for Variable Declaration
+
+            Used to create nodes for variable declarations and assignments with
+            values or function call for the respective nodes in the clang AST
+
+            Returns
+            =======
+
+            A variable node as Declaration, with the initial value if given
+
+            Raises
+            ======
+
+            NotImplementedError : if called for data types not currently
+            implemented
+
+            Notes
+            =====
+
+            The function currently supports following data types:
+
+            Boolean:
+                bool, _Bool
+
+            Integer:
+                8-bit: signed char and unsigned char
+                16-bit: short, short int, signed short,
+                    signed short int, unsigned short, unsigned short int
+                32-bit: int, signed int, unsigned int
+                64-bit: long, long int, signed long,
+                    signed long int, unsigned long, unsigned long int
+
+            Floating point:
+                Single Precision: float
+                Double Precision: double
+                Extended Precision: long double
+
+            """
+            if node.type.kind in self._data_types["int"]:
+                type = self._data_types["int"][node.type.kind]
+            elif node.type.kind in self._data_types["float"]:
+                type = self._data_types["float"][node.type.kind]
+            elif node.type.kind in self._data_types["bool"]:
+                type = self._data_types["bool"][node.type.kind]
+            else:
+                raise NotImplementedError("Only bool, int "
+                    "and float are supported")
+            try:
+                children = node.get_children()
+                child = next(children)
+                #ignoring namespace and type details for the variable
+                while child.kind == cin.CursorKind.NAMESPACE_REF:
+                    child = next(children)
+
+                while child.kind == cin.CursorKind.TYPE_REF:
+                    child = next(children)
+
+                val = self.transform(child)
+
+                supported_rhs = [
+                    cin.CursorKind.INTEGER_LITERAL,
+                    cin.CursorKind.FLOATING_LITERAL,
+                    cin.CursorKind.UNEXPOSED_EXPR,
+                    cin.CursorKind.BINARY_OPERATOR,
+                    cin.CursorKind.PAREN_EXPR,
+                    cin.CursorKind.UNARY_OPERATOR,
+                    cin.CursorKind.CXX_BOOL_LITERAL_EXPR
+                ]
+
+                if child.kind in supported_rhs:
+                    if isinstance(val, str):
+                        value = Symbol(val)
+                    elif isinstance(val, bool):
+                        if node.type.kind in self._data_types["int"]:
+                            value = Integer(0) if val == False else Integer(1)
+                        elif node.type.kind in self._data_types["float"]:
+                            value = Float(0.0) if val == False else Float(1.0)
+                        elif node.type.kind in self._data_types["bool"]:
+                            value = sympify(val)
+                    elif isinstance(val, (Integer, int, Float, float)):
+                        if node.type.kind in self._data_types["int"]:
+                            value = Integer(val)
+                        elif node.type.kind in self._data_types["float"]:
+                            value = Float(val)
+                        elif node.type.kind in self._data_types["bool"]:
+                            value = sympify(bool(val))
+                    else:
+                        value = val
+
+                    return Variable(
+                    node.spelling
+                    ).as_Declaration(
+                        type = type,
+                        value = value
+                    )
+
+                elif child.kind == cin.CursorKind.CALL_EXPR:
+                    return Variable(
+                        node.spelling
+                        ).as_Declaration(
+                            value = val
+                        )
+
+                else:
+                    raise NotImplementedError("Given "
+                        "variable declaration \"{}\" "
+                        "is not possible to parse yet!"
+                        .format(" ".join(
+                            t.spelling for t in node.get_tokens()
+                            )
+                        ))
+
+            except StopIteration:
+                return Variable(
+                node.spelling
+                ).as_Declaration(
+                    type = type
+                )
+
+        def transform_function_decl(self, node):
+            """Transformation Function For Function Declaration
+
+            Used to create nodes for function declarations and definitions for
+            the respective nodes in the clang AST
+
+            Returns
+            =======
+
+            function : Codegen AST node
+                - FunctionPrototype node if function body is not present
+                - FunctionDefinition node if the function body is present
+
+
+            """
+
+            if node.result_type.kind in self._data_types["int"]:
+                ret_type = self._data_types["int"][node.result_type.kind]
+            elif node.result_type.kind in self._data_types["float"]:
+                ret_type = self._data_types["float"][node.result_type.kind]
+            elif node.result_type.kind in self._data_types["bool"]:
+                ret_type = self._data_types["bool"][node.result_type.kind]
+            elif node.result_type.kind in self._data_types["void"]:
+                ret_type = self._data_types["void"][node.result_type.kind]
+            else:
+                raise NotImplementedError("Only void, bool, int "
+                    "and float are supported")
+            body = []
+            param = []
+            try:
+                children = node.get_children()
+                child = next(children)
+
+                # If the node has any children, the first children will be the
+                # return type and namespace for the function declaration. These
+                # nodes can be ignored.
+                while child.kind == cin.CursorKind.NAMESPACE_REF:
+                    child = next(children)
+
+                while child.kind == cin.CursorKind.TYPE_REF:
+                    child = next(children)
+
+
+                # Subsequent nodes will be the parameters for the function.
+                try:
+                    while True:
+                        decl = self.transform(child)
+                        if (child.kind == cin.CursorKind.PARM_DECL):
+                            param.append(decl)
+                        elif (child.kind == cin.CursorKind.COMPOUND_STMT):
+                            for val in decl:
+                                body.append(val)
+                        else:
+                            body.append(decl)
+                        child = next(children)
+                except StopIteration:
+                    pass
+            except StopIteration:
+                pass
+
+            if body == []:
+                function = FunctionPrototype(
+                    return_type = ret_type,
+                    name = node.spelling,
+                    parameters = param
+                )
+            else:
+                function = FunctionDefinition(
+                    return_type = ret_type,
+                    name = node.spelling,
+                    parameters = param,
+                    body = body
+                )
+            return function
+
+        def transform_parm_decl(self, node):
+            """Transformation function for Parameter Declaration
+
+            Used to create parameter nodes for the required functions for the
+            respective nodes in the clang AST
+
+            Returns
+            =======
+
+            param : Codegen AST Node
+                Variable node with the value and type of the variable
+
+            Raises
+            ======
+
+            ValueError if multiple children encountered in the parameter node
+
+            """
+            if node.type.kind in self._data_types["int"]:
+                type = self._data_types["int"][node.type.kind]
+            elif node.type.kind in self._data_types["float"]:
+                type = self._data_types["float"][node.type.kind]
+            elif node.type.kind in self._data_types["bool"]:
+                type = self._data_types["bool"][node.type.kind]
+            else:
+                raise NotImplementedError("Only bool, int "
+                    "and float are supported")
+            try:
+                children = node.get_children()
+                child = next(children)
+
+                # Any namespace nodes can be ignored
+                while child.kind in [cin.CursorKind.NAMESPACE_REF,
+                                     cin.CursorKind.TYPE_REF,
+                                     cin.CursorKind.TEMPLATE_REF]:
+                    child = next(children)
+
+                # If there is a child, it is the default value of the parameter.
+                lit = self.transform(child)
+                if node.type.kind in self._data_types["int"]:
+                    val = Integer(lit)
+                elif node.type.kind in self._data_types["float"]:
+                    val = Float(lit)
+                elif node.type.kind in self._data_types["bool"]:
+                    val = sympify(bool(lit))
+                else:
+                    raise NotImplementedError("Only bool, int "
+                        "and float are supported")
+
+                param = Variable(
+                    node.spelling
+                ).as_Declaration(
+                    type = type,
+                    value = val
+                )
+            except StopIteration:
+                param = Variable(
+                    node.spelling
+                ).as_Declaration(
+                    type = type
+                )
+
+            try:
+                self.transform(next(children))
+                raise ValueError("Can't handle multiple children on parameter")
+            except StopIteration:
+                pass
+
+            return param
+
+        def transform_integer_literal(self, node):
+            """Transformation function for integer literal
+
+            Used to get the value and type of the given integer literal.
+
+            Returns
+            =======
+
+            val : list
+                List with two arguments type and Value
+                type contains the type of the integer
+                value contains the value stored in the variable
+
+            Notes
+            =====
+
+            Only Base Integer type supported for now
+
+            """
+            try:
+                value = next(node.get_tokens()).spelling
+            except StopIteration:
+                # No tokens
+                value = node.literal
+            return int(value)
+
+        def transform_floating_literal(self, node):
+            """Transformation function for floating literal
+
+            Used to get the value and type of the given floating literal.
+
+            Returns
+            =======
+
+            val : list
+                List with two arguments type and Value
+                type contains the type of float
+                value contains the value stored in the variable
+
+            Notes
+            =====
+
+            Only Base Float type supported for now
+
+            """
+            try:
+                value = next(node.get_tokens()).spelling
+            except (StopIteration, ValueError):
+                # No tokens
+                value = node.literal
+            return float(value)
+
+        def transform_string_literal(self, node):
+            #TODO: No string type in AST
+            #type =
+            #try:
+            #    value = next(node.get_tokens()).spelling
+            #except (StopIteration, ValueError):
+                # No tokens
+            #    value = node.literal
+            #val = [type, value]
+            #return val
+            pass
+
+        def transform_character_literal(self, node):
+            """Transformation function for character literal
+
+            Used to get the value of the given character literal.
+
+            Returns
+            =======
+
+            val : int
+                val contains the ascii value of the character literal
+
+            Notes
+            =====
+
+            Only for cases where character is assigned to a integer value,
+            since character literal is not in SymPy AST
+
+            """
+            try:
+               value = next(node.get_tokens()).spelling
+            except (StopIteration, ValueError):
+                # No tokens
+               value = node.literal
+            return ord(str(value[1]))
+
+        def transform_cxx_bool_literal_expr(self, node):
+            """Transformation function for boolean literal
+
+            Used to get the value of the given boolean literal.
+
+            Returns
+            =======
+
+            value : bool
+                value contains the boolean value of the variable
+
+            """
+            try:
+                value = next(node.get_tokens()).spelling
+            except (StopIteration, ValueError):
+                value = node.literal
+            return True if value == 'true' else False
+
+        def transform_unexposed_decl(self,node):
+            """Transformation function for unexposed declarations"""
+            pass
+
+        def transform_unexposed_expr(self, node):
+            """Transformation function for unexposed expression
+
+            Unexposed expressions are used to wrap float, double literals and
+            expressions
+
+            Returns
+            =======
+
+            expr : Codegen AST Node
+                the result from the wrapped expression
+
+            None : NoneType
+                No childs are found for the node
+
+            Raises
+            ======
+
+            ValueError if the expression contains multiple children
+
+            """
+            # Ignore unexposed nodes; pass whatever is the first
+            # (and should be only) child unaltered.
+            try:
+                children = node.get_children()
+                expr = self.transform(next(children))
+            except StopIteration:
+                return None
+
+            try:
+                next(children)
+                raise ValueError("Unexposed expression has > 1 children.")
+            except StopIteration:
+                pass
+
+            return expr
+
+        def transform_decl_ref_expr(self, node):
+            """Returns the name of the declaration reference"""
+            return node.spelling
+
+        def transform_call_expr(self, node):
+            """Transformation function for a call expression
+
+            Used to create function call nodes for the function calls present
+            in the C code
+
+            Returns
+            =======
+
+            FunctionCall : Codegen AST Node
+                FunctionCall node with parameters if any parameters are present
+
+            """
+            param = []
+            children = node.get_children()
+            child = next(children)
+
+            while child.kind == cin.CursorKind.NAMESPACE_REF:
+                child = next(children)
+            while child.kind == cin.CursorKind.TYPE_REF:
+                child = next(children)
+
+            first_child = self.transform(child)
+            try:
+                for child in children:
+                    arg = self.transform(child)
+                    if (child.kind == cin.CursorKind.INTEGER_LITERAL):
+                        param.append(Integer(arg))
+                    elif (child.kind == cin.CursorKind.FLOATING_LITERAL):
+                        param.append(Float(arg))
+                    else:
+                        param.append(arg)
+                return FunctionCall(first_child, param)
+
+            except StopIteration:
+                return FunctionCall(first_child)
+
+        def transform_return_stmt(self, node):
+            """Returns the Return Node for a return statement"""
+            return Return(next(node.get_children()).spelling)
+
+        def transform_compound_stmt(self, node):
+            """Transformation function for compond statemets
+
+            Returns
+            =======
+
+            expr : list
+                list of Nodes for the expressions present in the statement
+
+            None : NoneType
+                if the compound statement is empty
+
+            """
+            try:
+                expr = []
+                children = node.get_children()
+                for child in children:
+                    expr.append(self.transform(child))
+            except StopIteration:
+                return None
+            return expr
+
+        def transform_decl_stmt(self, node):
+            """Transformation function for declaration statements
+
+            These statements are used to wrap different kinds of declararions
+            like variable or function declaration
+            The function calls the transformer function for the child of the
+            given node
+
+            Returns
+            =======
+
+            statement : Codegen AST Node
+                contains the node returned by the children node for the type of
+                declaration
+
+            Raises
+            ======
+
+            ValueError if multiple children present
+
+            """
+            try:
+                children = node.get_children()
+                statement = self.transform(next(children))
+            except StopIteration:
+                pass
+
+            try:
+                self.transform(next(children))
+                raise ValueError("Don't know how to handle multiple statements")
+            except StopIteration:
+                pass
+
+            return statement
+
+        def transform_paren_expr(self, node):
+            """Transformation function for Parenthesized expressions
+
+            Returns the result from its children nodes
+
+            """
+            return self.transform(next(node.get_children()))
+
+        def transform_compound_assignment_operator(self, node):
+            """Transformation function for handling shorthand operators
+
+            Returns
+            =======
+
+            augmented_assignment_expression: Codegen AST node
+                    shorthand assignment expression represented as Codegen AST
+
+            Raises
+            ======
+
+            NotImplementedError
+                If the shorthand operator for bitwise operators
+                (~=, ^=, &=, |=, <<=, >>=) is encountered
+
+            """
+            return self.transform_binary_operator(node)
+
+        def transform_unary_operator(self, node):
+            """Transformation function for handling unary operators
+
+            Returns
+            =======
+
+            unary_expression: Codegen AST node
+                    simplified unary expression represented as Codegen AST
+
+            Raises
+            ======
+
+            NotImplementedError
+                If dereferencing operator(*), address operator(&) or
+                bitwise NOT operator(~) is encountered
+
+            """
+            # supported operators list
+            operators_list = ['+', '-', '++', '--', '!']
+            tokens = list(node.get_tokens())
+
+            # it can be either pre increment/decrement or any other operator from the list
+            if tokens[0].spelling in operators_list:
+                child = self.transform(next(node.get_children()))
+                # (decl_ref) e.g.; int a = ++b; or simply ++b;
+                if isinstance(child, str):
+                    if tokens[0].spelling == '+':
+                        return Symbol(child)
+                    if tokens[0].spelling == '-':
+                        return Mul(Symbol(child), -1)
+                    if tokens[0].spelling == '++':
+                        return PreIncrement(Symbol(child))
+                    if tokens[0].spelling == '--':
+                        return PreDecrement(Symbol(child))
+                    if tokens[0].spelling == '!':
+                        return Not(Symbol(child))
+                # e.g.; int a = -1; or int b = -(1 + 2);
+                else:
+                    if tokens[0].spelling == '+':
+                        return child
+                    if tokens[0].spelling == '-':
+                        return Mul(child, -1)
+                    if tokens[0].spelling == '!':
+                        return Not(sympify(bool(child)))
+
+            # it can be either post increment/decrement
+            # since variable name is obtained in token[0].spelling
+            elif tokens[1].spelling in ['++', '--']:
+                child = self.transform(next(node.get_children()))
+                if tokens[1].spelling == '++':
+                    return PostIncrement(Symbol(child))
+                if tokens[1].spelling == '--':
+                    return PostDecrement(Symbol(child))
+            else:
+                raise NotImplementedError("Dereferencing operator, "
+                    "Address operator and bitwise NOT operator "
+                    "have not been implemented yet!")
+
+        def transform_binary_operator(self, node):
+            """Transformation function for handling binary operators
+
+            Returns
+            =======
+
+            binary_expression: Codegen AST node
+                    simplified binary expression represented as Codegen AST
+
+            Raises
+            ======
+
+            NotImplementedError
+                If a bitwise operator or
+                unary operator(which is a child of any binary
+                operator in Clang AST) is encountered
+
+            """
+            # get all the tokens of assignment
+            # and store it in the tokens list
+            tokens = list(node.get_tokens())
+
+            # supported operators list
+            operators_list = ['+', '-', '*', '/', '%','=',
+            '>', '>=', '<', '<=', '==', '!=', '&&', '||', '+=', '-=',
+            '*=', '/=', '%=']
+
+            # this stack will contain variable content
+            # and type of variable in the rhs
+            combined_variables_stack = []
+
+            # this stack will contain operators
+            # to be processed in the rhs
+            operators_stack = []
+
+            # iterate through every token
+            for token in tokens:
+                # token is either '(', ')' or
+                # any of the supported operators from the operator list
+                if token.kind == cin.TokenKind.PUNCTUATION:
+
+                    # push '(' to the operators stack
+                    if token.spelling == '(':
+                        operators_stack.append('(')
+
+                    elif token.spelling == ')':
+                        # keep adding the expression to the
+                        # combined variables stack unless
+                        # '(' is found
+                        while (operators_stack
+                            and operators_stack[-1] != '('):
+                            if len(combined_variables_stack) < 2:
+                                raise NotImplementedError(
+                                    "Unary operators as a part of "
+                                    "binary operators is not "
+                                    "supported yet!")
+                            rhs = combined_variables_stack.pop()
+                            lhs = combined_variables_stack.pop()
+                            operator = operators_stack.pop()
+                            combined_variables_stack.append(
+                                self.perform_operation(
+                                lhs, rhs, operator))
+
+                        # pop '('
+                        operators_stack.pop()
+
+                    # token is an operator (supported)
+                    elif token.spelling in operators_list:
+                        while (operators_stack
+                            and self.priority_of(token.spelling)
+                            <= self.priority_of(
+                            operators_stack[-1])):
+                            if len(combined_variables_stack) < 2:
+                                raise NotImplementedError(
+                                    "Unary operators as a part of "
+                                    "binary operators is not "
+                                    "supported yet!")
+                            rhs = combined_variables_stack.pop()
+                            lhs = combined_variables_stack.pop()
+                            operator = operators_stack.pop()
+                            combined_variables_stack.append(
+                                self.perform_operation(
+                                lhs, rhs, operator))
+
+                        # push current operator
+                        operators_stack.append(token.spelling)
+
+                    # token is a bitwise operator
+                    elif token.spelling in ['&', '|', '^', '<<', '>>']:
+                        raise NotImplementedError(
+                            "Bitwise operator has not been "
+                            "implemented yet!")
+
+                    # token is a shorthand bitwise operator
+                    elif token.spelling in ['&=', '|=', '^=', '<<=',
+                    '>>=']:
+                        raise NotImplementedError(
+                            "Shorthand bitwise operator has not been "
+                            "implemented yet!")
+                    else:
+                        raise NotImplementedError(
+                            "Given token {} is not implemented yet!"
+                            .format(token.spelling))
+
+                # token is an identifier(variable)
+                elif token.kind == cin.TokenKind.IDENTIFIER:
+                    combined_variables_stack.append(
+                        [token.spelling, 'identifier'])
+
+                # token is a literal
+                elif token.kind == cin.TokenKind.LITERAL:
+                    combined_variables_stack.append(
+                        [token.spelling, 'literal'])
+
+                # token is a keyword, either true or false
+                elif (token.kind == cin.TokenKind.KEYWORD
+                    and token.spelling in ['true', 'false']):
+                    combined_variables_stack.append(
+                        [token.spelling, 'boolean'])
+                else:
+                    raise NotImplementedError(
+                        "Given token {} is not implemented yet!"
+                        .format(token.spelling))
+
+            # process remaining operators
+            while operators_stack:
+                if len(combined_variables_stack) < 2:
+                    raise NotImplementedError(
+                        "Unary operators as a part of "
+                        "binary operators is not "
+                        "supported yet!")
+                rhs = combined_variables_stack.pop()
+                lhs = combined_variables_stack.pop()
+                operator = operators_stack.pop()
+                combined_variables_stack.append(
+                    self.perform_operation(lhs, rhs, operator))
+
+            return combined_variables_stack[-1][0]
+
+        def priority_of(self, op):
+            """To get the priority of given operator"""
+            if op in ['=', '+=', '-=', '*=', '/=', '%=']:
+                return 1
+            if op in ['&&', '||']:
+                return 2
+            if op in ['<', '<=', '>', '>=', '==', '!=']:
+                return 3
+            if op in ['+', '-']:
+                return 4
+            if op in ['*', '/', '%']:
+                return 5
+            return 0
+
+        def perform_operation(self, lhs, rhs, op):
+            """Performs operation supported by the SymPy core
+
+            Returns
+            =======
+
+            combined_variable: list
+                contains variable content and type of variable
+
+            """
+            lhs_value = self.get_expr_for_operand(lhs)
+            rhs_value = self.get_expr_for_operand(rhs)
+            if op == '+':
+                return [Add(lhs_value, rhs_value), 'expr']
+            if op == '-':
+                return [Add(lhs_value, -rhs_value), 'expr']
+            if op == '*':
+                return [Mul(lhs_value, rhs_value), 'expr']
+            if op == '/':
+                return [Mul(lhs_value, Pow(rhs_value, Integer(-1))), 'expr']
+            if op == '%':
+                return [Mod(lhs_value, rhs_value), 'expr']
+            if op in ['<', '<=', '>', '>=', '==', '!=']:
+                return [Rel(lhs_value, rhs_value, op), 'expr']
+            if op == '&&':
+                return [And(as_Boolean(lhs_value), as_Boolean(rhs_value)), 'expr']
+            if op == '||':
+                return [Or(as_Boolean(lhs_value), as_Boolean(rhs_value)), 'expr']
+            if op == '=':
+                return [Assignment(Variable(lhs_value), rhs_value), 'expr']
+            if op in ['+=', '-=', '*=', '/=', '%=']:
+                return [aug_assign(Variable(lhs_value), op[0], rhs_value), 'expr']
+
+        def get_expr_for_operand(self, combined_variable):
+            """Gives out SymPy Codegen AST node
+
+            AST node returned is corresponding to
+            combined variable passed.Combined variable contains
+            variable content and type of variable
+
+            """
+            if combined_variable[1] == 'identifier':
+                return Symbol(combined_variable[0])
+            if combined_variable[1] == 'literal':
+                if '.' in combined_variable[0]:
+                    return Float(float(combined_variable[0]))
+                else:
+                    return Integer(int(combined_variable[0]))
+            if combined_variable[1] == 'expr':
+                return combined_variable[0]
+            if combined_variable[1] == 'boolean':
+                    return true if combined_variable[0] == 'true' else false
+
+        def transform_null_stmt(self, node):
+            """Handles Null Statement and returns None"""
+            return none
+
+        def transform_while_stmt(self, node):
+            """Transformation function for handling while statement
+
+            Returns
+            =======
+
+            while statement : Codegen AST Node
+                contains the while statement node having condition and
+                statement block
+
+            """
+            children = node.get_children()
+
+            condition = self.transform(next(children))
+            statements = self.transform(next(children))
+
+            if isinstance(statements, list):
+                statement_block = CodeBlock(*statements)
+            else:
+                statement_block = CodeBlock(statements)
+
+            return While(condition, statement_block)
+
+
+
+else:
+    class CCodeConverter():  # type: ignore
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Module not Installed")
+
+
+def parse_c(source):
+    """Function for converting a C source code
+
+    The function reads the source code present in the given file and parses it
+    to give out SymPy Expressions
+
+    Returns
+    =======
+
+    src : list
+        List of Python expression strings
+
+    """
+    converter = CCodeConverter()
+    if os.path.exists(source):
+        src = converter.parse(source, flags = [])
+    else:
+        src = converter.parse_str(source, flags = [])
+    return src

venv/lib/python3.10/site-packages/sympy/parsing/fortran/__init__.py

@@ -0,0 +1 @@
+"""Used for translating Fortran source code into a SymPy expression. """

venv/lib/python3.10/site-packages/sympy/parsing/fortran/fortran_parser.py

@@ -0,0 +1,347 @@
+from sympy.external import import_module
+
+lfortran = import_module('lfortran')
+
+if lfortran:
+    from sympy.codegen.ast import (Variable, IntBaseType, FloatBaseType, String,
+                                   Return, FunctionDefinition, Assignment)
+    from sympy.core import Add, Mul, Integer, Float
+    from sympy.core.symbol import Symbol
+
+    asr_mod = lfortran.asr
+    asr = lfortran.asr.asr
+    src_to_ast = lfortran.ast.src_to_ast
+    ast_to_asr = lfortran.semantic.ast_to_asr.ast_to_asr
+
+    """
+    This module contains all the necessary Classes and Function used to Parse
+    Fortran code into SymPy expression
+
+    The module and its API are currently under development and experimental.
+    It is also dependent on LFortran for the ASR that is converted to SymPy syntax
+    which is also under development.
+    The module only supports the features currently supported by the LFortran ASR
+    which will be updated as the development of LFortran and this module progresses
+
+    You might find unexpected bugs and exceptions while using the module, feel free
+    to report them to the SymPy Issue Tracker
+
+    The API for the module might also change while in development if better and
+    more effective ways are discovered for the process
+
+    Features Supported
+    ==================
+
+    - Variable Declarations (integers and reals)
+    - Function Definitions
+    - Assignments and Basic Binary Operations
+
+
+    Notes
+    =====
+
+    The module depends on an external dependency
+
+    LFortran : Required to parse Fortran source code into ASR
+
+
+    References
+    ==========
+
+    .. [1] https://github.com/sympy/sympy/issues
+    .. [2] https://gitlab.com/lfortran/lfortran
+    .. [3] https://docs.lfortran.org/
+
+    """
+
+
+    class ASR2PyVisitor(asr.ASTVisitor):  # type: ignore
+        """
+        Visitor Class for LFortran ASR
+
+        It is a Visitor class derived from asr.ASRVisitor which visits all the
+        nodes of the LFortran ASR and creates corresponding AST node for each
+        ASR node
+
+        """
+
+        def __init__(self):
+            """Initialize the Parser"""
+            self._py_ast = []
+
+        def visit_TranslationUnit(self, node):
+            """
+            Function to visit all the elements of the Translation Unit
+            created by LFortran ASR
+            """
+            for s in node.global_scope.symbols:
+                sym = node.global_scope.symbols[s]
+                self.visit(sym)
+            for item in node.items:
+                self.visit(item)
+
+        def visit_Assignment(self, node):
+            """Visitor Function for Assignment
+
+            Visits each Assignment is the LFortran ASR and creates corresponding
+            assignment for SymPy.
+
+            Notes
+            =====
+
+            The function currently only supports variable assignment and binary
+            operation assignments of varying multitudes. Any type of numberS or
+            array is not supported.
+
+            Raises
+            ======
+
+            NotImplementedError() when called for Numeric assignments or Arrays
+
+            """
+            # TODO: Arithmetic Assignment
+            if isinstance(node.target, asr.Variable):
+                target = node.target
+                value = node.value
+                if isinstance(value, asr.Variable):
+                    new_node = Assignment(
+                            Variable(
+                                    target.name
+                                ),
+                            Variable(
+                                    value.name
+                                )
+                        )
+                elif (type(value) == asr.BinOp):
+                    exp_ast = call_visitor(value)
+                    for expr in exp_ast:
+                        new_node = Assignment(
+                                Variable(target.name),
+                                expr
+                            )
+                else:
+                    raise NotImplementedError("Numeric assignments not supported")
+            else:
+                raise NotImplementedError("Arrays not supported")
+            self._py_ast.append(new_node)
+
+        def visit_BinOp(self, node):
+            """Visitor Function for Binary Operations
+
+            Visits each binary operation present in the LFortran ASR like addition,
+            subtraction, multiplication, division and creates the corresponding
+            operation node in SymPy's AST
+
+            In case of more than one binary operations, the function calls the
+            call_visitor() function on the child nodes of the binary operations
+            recursively until all the operations have been processed.
+
+            Notes
+            =====
+
+            The function currently only supports binary operations with Variables
+            or other binary operations. Numerics are not supported as of yet.
+
+            Raises
+            ======
+
+            NotImplementedError() when called for Numeric assignments
+
+            """
+            # TODO: Integer Binary Operations
+            op = node.op
+            lhs = node.left
+            rhs = node.right
+
+            if (type(lhs) == asr.Variable):
+                left_value = Symbol(lhs.name)
+            elif(type(lhs) == asr.BinOp):
+                l_exp_ast = call_visitor(lhs)
+                for exp in l_exp_ast:
+                    left_value = exp
+            else:
+                raise NotImplementedError("Numbers Currently not supported")
+
+            if (type(rhs) == asr.Variable):
+                right_value = Symbol(rhs.name)
+            elif(type(rhs) == asr.BinOp):
+                r_exp_ast = call_visitor(rhs)
+                for exp in r_exp_ast:
+                    right_value = exp
+            else:
+                raise NotImplementedError("Numbers Currently not supported")
+
+            if isinstance(op, asr.Add):
+                new_node = Add(left_value, right_value)
+            elif isinstance(op, asr.Sub):
+                new_node = Add(left_value, -right_value)
+            elif isinstance(op, asr.Div):
+                new_node = Mul(left_value, 1/right_value)
+            elif isinstance(op, asr.Mul):
+                new_node = Mul(left_value, right_value)
+
+            self._py_ast.append(new_node)
+
+        def visit_Variable(self, node):
+            """Visitor Function for Variable Declaration
+
+            Visits each variable declaration present in the ASR and creates a
+            Symbol declaration for each variable
+
+            Notes
+            =====
+
+            The functions currently only support declaration of integer and
+            real variables. Other data types are still under development.
+
+            Raises
+            ======
+
+            NotImplementedError() when called for unsupported data types
+
+            """
+            if isinstance(node.type, asr.Integer):
+                var_type = IntBaseType(String('integer'))
+                value = Integer(0)
+            elif isinstance(node.type, asr.Real):
+                var_type = FloatBaseType(String('real'))
+                value = Float(0.0)
+            else:
+                raise NotImplementedError("Data type not supported")
+
+            if not (node.intent == 'in'):
+                new_node = Variable(
+                    node.name
+                ).as_Declaration(
+                    type = var_type,
+                    value = value
+                )
+                self._py_ast.append(new_node)
+
+        def visit_Sequence(self, seq):
+            """Visitor Function for code sequence
+
+            Visits a code sequence/ block and calls the visitor function on all the
+            children of the code block to create corresponding code in python
+
+            """
+            if seq is not None:
+                for node in seq:
+                    self._py_ast.append(call_visitor(node))
+
+        def visit_Num(self, node):
+            """Visitor Function for Numbers in ASR
+
+            This function is currently under development and will be updated
+            with improvements in the LFortran ASR
+
+            """
+            # TODO:Numbers when the LFortran ASR is updated
+            # self._py_ast.append(Integer(node.n))
+            pass
+
+        def visit_Function(self, node):
+            """Visitor Function for function Definitions
+
+            Visits each function definition present in the ASR and creates a
+            function definition node in the Python AST with all the elements of the
+            given function
+
+            The functions declare all the variables required as SymPy symbols in
+            the function before the function definition
+
+            This function also the call_visior_function to parse the contents of
+            the function body
+
+            """
+            # TODO: Return statement, variable declaration
+            fn_args = [Variable(arg_iter.name) for arg_iter in node.args]
+            fn_body = []
+            fn_name = node.name
+            for i in node.body:
+                fn_ast = call_visitor(i)
+            try:
+                fn_body_expr = fn_ast
+            except UnboundLocalError:
+                fn_body_expr = []
+            for sym in node.symtab.symbols:
+                decl = call_visitor(node.symtab.symbols[sym])
+                for symbols in decl:
+                    fn_body.append(symbols)
+            for elem in fn_body_expr:
+                fn_body.append(elem)
+            fn_body.append(
+                Return(
+                    Variable(
+                        node.return_var.name
+                    )
+                )
+            )
+            if isinstance(node.return_var.type, asr.Integer):
+                ret_type = IntBaseType(String('integer'))
+            elif isinstance(node.return_var.type, asr.Real):
+                ret_type = FloatBaseType(String('real'))
+            else:
+                raise NotImplementedError("Data type not supported")
+            new_node = FunctionDefinition(
+                        return_type = ret_type,
+                        name = fn_name,
+                        parameters = fn_args,
+                        body = fn_body
+                    )
+            self._py_ast.append(new_node)
+
+        def ret_ast(self):
+            """Returns the AST nodes"""
+            return self._py_ast
+else:
+    class ASR2PyVisitor():  # type: ignore
+        def __init__(self, *args, **kwargs):
+            raise ImportError('lfortran not available')
+
+def call_visitor(fort_node):
+    """Calls the AST Visitor on the Module
+
+    This function is used to call the AST visitor for a program or module
+    It imports all the required modules and calls the visit() function
+    on the given node
+
+    Parameters
+    ==========
+
+    fort_node : LFortran ASR object
+        Node for the operation for which the NodeVisitor is called
+
+    Returns
+    =======
+
+    res_ast : list
+        list of SymPy AST Nodes
+
+    """
+    v = ASR2PyVisitor()
+    v.visit(fort_node)
+    res_ast = v.ret_ast()
+    return res_ast
+
+
+def src_to_sympy(src):
+    """Wrapper function to convert the given Fortran source code to SymPy Expressions
+
+    Parameters
+    ==========
+
+    src : string
+        A string with the Fortran source code
+
+    Returns
+    =======
+
+    py_src : string
+        A string with the Python source code compatible with SymPy
+
+    """
+    a_ast = src_to_ast(src, translation_unit=False)
+    a = ast_to_asr(a_ast)
+    py_src = call_visitor(a)
+    return py_src

venv/lib/python3.10/site-packages/sympy/parsing/latex/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright 2016, latex2sympy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

venv/lib/python3.10/site-packages/sympy/parsing/latex/LaTeX.g4

@@ -0,0 +1,312 @@
+/*
+ ANTLR4 LaTeX Math Grammar
+
+ Ported from latex2sympy by @augustt198 https://github.com/augustt198/latex2sympy See license in
+ LICENSE.txt
+ */
+
+/*
+ After changing this file, it is necessary to run `python setup.py antlr` in the root directory of
+ the repository. This will regenerate the code in `sympy/parsing/latex/_antlr/*.py`.
+ */
+
+grammar LaTeX;
+
+options {
+	language = Python3;
+}
+
+WS: [ \t\r\n]+ -> skip;
+THINSPACE: ('\\,' | '\\thinspace') -> skip;
+MEDSPACE: ('\\:' | '\\medspace') -> skip;
+THICKSPACE: ('\\;' | '\\thickspace') -> skip;
+QUAD: '\\quad' -> skip;
+QQUAD: '\\qquad' -> skip;
+NEGTHINSPACE: ('\\!' | '\\negthinspace') -> skip;
+NEGMEDSPACE: '\\negmedspace' -> skip;
+NEGTHICKSPACE: '\\negthickspace' -> skip;
+CMD_LEFT: '\\left' -> skip;
+CMD_RIGHT: '\\right' -> skip;
+
+IGNORE:
+	(
+		'\\vrule'
+		| '\\vcenter'
+		| '\\vbox'
+		| '\\vskip'
+		| '\\vspace'
+		| '\\hfil'
+		| '\\*'
+		| '\\-'
+		| '\\.'
+		| '\\/'
+		| '\\"'
+		| '\\('
+		| '\\='
+	) -> skip;
+
+ADD: '+';
+SUB: '-';
+MUL: '*';
+DIV: '/';
+
+L_PAREN: '(';
+R_PAREN: ')';
+L_BRACE: '{';
+R_BRACE: '}';
+L_BRACE_LITERAL: '\\{';
+R_BRACE_LITERAL: '\\}';
+L_BRACKET: '[';
+R_BRACKET: ']';
+
+BAR: '|';
+
+R_BAR: '\\right|';
+L_BAR: '\\left|';
+
+L_ANGLE: '\\langle';
+R_ANGLE: '\\rangle';
+FUNC_LIM: '\\lim';
+LIM_APPROACH_SYM:
+	'\\to'
+	| '\\rightarrow'
+	| '\\Rightarrow'
+	| '\\longrightarrow'
+	| '\\Longrightarrow';
+FUNC_INT:
+    '\\int'
+    | '\\int\\limits';
+FUNC_SUM: '\\sum';
+FUNC_PROD: '\\prod';
+
+FUNC_EXP: '\\exp';
+FUNC_LOG: '\\log';
+FUNC_LG: '\\lg';
+FUNC_LN: '\\ln';
+FUNC_SIN: '\\sin';
+FUNC_COS: '\\cos';
+FUNC_TAN: '\\tan';
+FUNC_CSC: '\\csc';
+FUNC_SEC: '\\sec';
+FUNC_COT: '\\cot';
+
+FUNC_ARCSIN: '\\arcsin';
+FUNC_ARCCOS: '\\arccos';
+FUNC_ARCTAN: '\\arctan';
+FUNC_ARCCSC: '\\arccsc';
+FUNC_ARCSEC: '\\arcsec';
+FUNC_ARCCOT: '\\arccot';
+
+FUNC_SINH: '\\sinh';
+FUNC_COSH: '\\cosh';
+FUNC_TANH: '\\tanh';
+FUNC_ARSINH: '\\arsinh';
+FUNC_ARCOSH: '\\arcosh';
+FUNC_ARTANH: '\\artanh';
+
+L_FLOOR: '\\lfloor';
+R_FLOOR: '\\rfloor';
+L_CEIL: '\\lceil';
+R_CEIL: '\\rceil';
+
+FUNC_SQRT: '\\sqrt';
+FUNC_OVERLINE: '\\overline';
+
+CMD_TIMES: '\\times';
+CMD_CDOT: '\\cdot';
+CMD_DIV: '\\div';
+CMD_FRAC:
+    '\\frac'
+    | '\\dfrac'
+    | '\\tfrac';
+CMD_BINOM: '\\binom';
+CMD_DBINOM: '\\dbinom';
+CMD_TBINOM: '\\tbinom';
+
+CMD_MATHIT: '\\mathit';
+
+UNDERSCORE: '_';
+CARET: '^';
+COLON: ':';
+
+fragment WS_CHAR: [ \t\r\n];
+DIFFERENTIAL: 'd' WS_CHAR*? ([a-zA-Z] | '\\' [a-zA-Z]+);
+
+LETTER: [a-zA-Z];
+DIGIT: [0-9];
+
+EQUAL: (('&' WS_CHAR*?)? '=') | ('=' (WS_CHAR*? '&')?);
+NEQ: '\\neq';
+
+LT: '<';
+LTE: ('\\leq' | '\\le' | LTE_Q | LTE_S);
+LTE_Q: '\\leqq';
+LTE_S: '\\leqslant';
+
+GT: '>';
+GTE: ('\\geq' | '\\ge' | GTE_Q | GTE_S);
+GTE_Q: '\\geqq';
+GTE_S: '\\geqslant';
+
+BANG: '!';
+
+SINGLE_QUOTES: '\''+;
+
+SYMBOL: '\\' [a-zA-Z]+;
+
+math: relation;
+
+relation:
+	relation (EQUAL | LT | LTE | GT | GTE | NEQ) relation
+	| expr;
+
+equality: expr EQUAL expr;
+
+expr: additive;
+
+additive: additive (ADD | SUB) additive | mp;
+
+// mult part
+mp:
+	mp (MUL | CMD_TIMES | CMD_CDOT | DIV | CMD_DIV | COLON) mp
+	| unary;
+
+mp_nofunc:
+	mp_nofunc (
+		MUL
+		| CMD_TIMES
+		| CMD_CDOT
+		| DIV
+		| CMD_DIV
+		| COLON
+	) mp_nofunc
+	| unary_nofunc;
+
+unary: (ADD | SUB) unary | postfix+;
+
+unary_nofunc:
+	(ADD | SUB) unary_nofunc
+	| postfix postfix_nofunc*;
+
+postfix: exp postfix_op*;
+postfix_nofunc: exp_nofunc postfix_op*;
+postfix_op: BANG | eval_at;
+
+eval_at:
+	BAR (eval_at_sup | eval_at_sub | eval_at_sup eval_at_sub);
+
+eval_at_sub: UNDERSCORE L_BRACE (expr | equality) R_BRACE;
+
+eval_at_sup: CARET L_BRACE (expr | equality) R_BRACE;
+
+exp: exp CARET (atom | L_BRACE expr R_BRACE) subexpr? | comp;
+
+exp_nofunc:
+	exp_nofunc CARET (atom | L_BRACE expr R_BRACE) subexpr?
+	| comp_nofunc;
+
+comp:
+	group
+	| abs_group
+	| func
+	| atom
+	| floor
+	| ceil;
+
+comp_nofunc:
+	group
+	| abs_group
+	| atom
+	| floor
+	| ceil;
+
+group:
+	L_PAREN expr R_PAREN
+	| L_BRACKET expr R_BRACKET
+	| L_BRACE expr R_BRACE
+	| L_BRACE_LITERAL expr R_BRACE_LITERAL;
+
+abs_group: BAR expr BAR;
+
+number: DIGIT+ (',' DIGIT DIGIT DIGIT)* ('.' DIGIT+)?;
+
+atom: (LETTER | SYMBOL) (subexpr? SINGLE_QUOTES? | SINGLE_QUOTES? subexpr?)
+	| number
+	| DIFFERENTIAL
+	| mathit
+	| frac
+	| binom
+	| bra
+	| ket;
+
+bra: L_ANGLE expr (R_BAR | BAR);
+ket: (L_BAR | BAR) expr R_ANGLE;
+
+mathit: CMD_MATHIT L_BRACE mathit_text R_BRACE;
+mathit_text: LETTER*;
+
+frac: CMD_FRAC (upperd = DIGIT | L_BRACE upper = expr R_BRACE)
+    (lowerd = DIGIT | L_BRACE lower = expr R_BRACE);
+
+binom:
+	(CMD_BINOM | CMD_DBINOM | CMD_TBINOM) L_BRACE n = expr R_BRACE L_BRACE k = expr R_BRACE;
+
+floor: L_FLOOR val = expr R_FLOOR;
+ceil: L_CEIL val = expr R_CEIL;
+
+func_normal:
+	FUNC_EXP
+	| FUNC_LOG
+	| FUNC_LG
+	| FUNC_LN
+	| FUNC_SIN
+	| FUNC_COS
+	| FUNC_TAN
+	| FUNC_CSC
+	| FUNC_SEC
+	| FUNC_COT
+	| FUNC_ARCSIN
+	| FUNC_ARCCOS
+	| FUNC_ARCTAN
+	| FUNC_ARCCSC
+	| FUNC_ARCSEC
+	| FUNC_ARCCOT
+	| FUNC_SINH
+	| FUNC_COSH
+	| FUNC_TANH
+	| FUNC_ARSINH
+	| FUNC_ARCOSH
+	| FUNC_ARTANH;
+
+func:
+	func_normal (subexpr? supexpr? | supexpr? subexpr?) (
+		L_PAREN func_arg R_PAREN
+		| func_arg_noparens
+	)
+	| (LETTER | SYMBOL) (subexpr? SINGLE_QUOTES? | SINGLE_QUOTES? subexpr?) // e.g. f(x), f_1'(x)
+	L_PAREN args R_PAREN
+	| FUNC_INT (subexpr supexpr | supexpr subexpr)? (
+		additive? DIFFERENTIAL
+		| frac
+		| additive
+	)
+	| FUNC_SQRT (L_BRACKET root = expr R_BRACKET)? L_BRACE base = expr R_BRACE
+	| FUNC_OVERLINE L_BRACE base = expr R_BRACE
+	| (FUNC_SUM | FUNC_PROD) (subeq supexpr | supexpr subeq) mp
+	| FUNC_LIM limit_sub mp;
+
+args: (expr ',' args) | expr;
+
+limit_sub:
+	UNDERSCORE L_BRACE (LETTER | SYMBOL) LIM_APPROACH_SYM expr (
+		CARET ((L_BRACE (ADD | SUB) R_BRACE) | ADD | SUB)
+	)? R_BRACE;
+
+func_arg: expr | (expr ',' func_arg);
+func_arg_noparens: mp_nofunc;
+
+subexpr: UNDERSCORE (atom | L_BRACE expr R_BRACE);
+supexpr: CARET (atom | L_BRACE expr R_BRACE);
+
+subeq: UNDERSCORE L_BRACE equality R_BRACE;
+supeq: UNDERSCORE L_BRACE equality R_BRACE;

venv/lib/python3.10/site-packages/sympy/parsing/latex/__init__.py

@@ -0,0 +1,35 @@
+from sympy.external import import_module
+from sympy.utilities.decorator import doctest_depends_on
+
+from .errors import LaTeXParsingError  # noqa
+
+@doctest_depends_on(modules=('antlr4',))
+def parse_latex(s):
+    r"""Converts the string ``s`` to a SymPy ``Expr``
+
+    Parameters
+    ==========
+
+    s : str
+        The LaTeX string to parse. In Python source containing LaTeX,
+        *raw strings* (denoted with ``r"``, like this one) are preferred,
+        as LaTeX makes liberal use of the ``\`` character, which would
+        trigger escaping in normal Python strings.
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.latex import parse_latex
+    >>> expr = parse_latex(r"\frac {1 + \sqrt {\a}} {\b}")
+    >>> expr
+    (sqrt(a) + 1)/b
+    >>> expr.evalf(4, subs=dict(a=5, b=2))
+    1.618
+    """
+
+    _latex = import_module(
+        'sympy.parsing.latex._parse_latex_antlr',
+        import_kwargs={'fromlist': ['X']})
+
+    if _latex is not None:
+        return _latex.parse_latex(s)

venv/lib/python3.10/site-packages/sympy/parsing/latex/_antlr/__init__.py

@@ -0,0 +1,9 @@
+# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
+#
+# Generated from ../LaTeX.g4, derived from latex2sympy
+#     latex2sympy is licensed under the MIT license
+#     https://github.com/augustt198/latex2sympy/blob/master/LICENSE.txt
+#
+# Generated with antlr4
+#    antlr4 is licensed under the BSD-3-Clause License
+#    https://github.com/antlr/antlr4/blob/master/LICENSE.txt