Add files using upload-large-folder tool

.gitattributes

@@ -332,3 +332,5 @@ llava_next/lib/python3.10/site-packages/pandas/tests/indexing/__pycache__/test_l
 parrot/lib/python3.10/site-packages/transformers/models/seamless_m4t_v2/__pycache__/modeling_seamless_m4t_v2.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/transformers/models/speecht5/__pycache__/modeling_speecht5.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/transformers/utils/__pycache__/dummy_tf_objects.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+parrot/lib/python3.10/site-packages/transformers/__pycache__/modeling_tf_utils.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+parrot/lib/python3.10/site-packages/transformers/__pycache__/trainer.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

llava_next/lib/python3.10/site-packages/wcwidth/table_vs16.py

@@ -0,0 +1,125 @@
+"""
+Exports VS16_NARROW_TO_WIDE table keyed by supporting unicode version level.
+
+This code generated by wcwidth/bin/update-tables.py on 2023-11-07 16:43:49 UTC.
+"""
+VS16_NARROW_TO_WIDE = {
+    '9.0.0': (
+        # Source: 9.0.0
+        # Date: 2023-02-01, 02:22:54 GMT
+        #
+        (0x00023, 0x00023,),  # Number Sign
+        (0x0002a, 0x0002a,),  # Asterisk
+        (0x00030, 0x00039,),  # Digit Zero              ..Digit Nine
+        (0x000a9, 0x000a9,),  # Copyright Sign
+        (0x000ae, 0x000ae,),  # Registered Sign
+        (0x0203c, 0x0203c,),  # Double Exclamation Mark
+        (0x02049, 0x02049,),  # Exclamation Question Mark
+        (0x02122, 0x02122,),  # Trade Mark Sign
+        (0x02139, 0x02139,),  # Information Source
+        (0x02194, 0x02199,),  # Left Right Arrow        ..South West Arrow
+        (0x021a9, 0x021aa,),  # Leftwards Arrow With Hoo..Rightwards Arrow With Ho
+        (0x02328, 0x02328,),  # Keyboard
+        (0x023cf, 0x023cf,),  # Eject Symbol
+        (0x023ed, 0x023ef,),  # Black Right-pointing Dou..Black Right-pointing Tri
+        (0x023f1, 0x023f2,),  # Stopwatch               ..Timer Clock
+        (0x023f8, 0x023fa,),  # Double Vertical Bar     ..Black Circle For Record
+        (0x024c2, 0x024c2,),  # Circled Latin Capital Letter M
+        (0x025aa, 0x025ab,),  # Black Small Square      ..White Small Square
+        (0x025b6, 0x025b6,),  # Black Right-pointing Triangle
+        (0x025c0, 0x025c0,),  # Black Left-pointing Triangle
+        (0x025fb, 0x025fc,),  # White Medium Square     ..Black Medium Square
+        (0x02600, 0x02604,),  # Black Sun With Rays     ..Comet
+        (0x0260e, 0x0260e,),  # Black Telephone
+        (0x02611, 0x02611,),  # Ballot Box With Check
+        (0x02618, 0x02618,),  # Shamrock
+        (0x0261d, 0x0261d,),  # White Up Pointing Index
+        (0x02620, 0x02620,),  # Skull And Crossbones
+        (0x02622, 0x02623,),  # Radioactive Sign        ..Biohazard Sign
+        (0x02626, 0x02626,),  # Orthodox Cross
+        (0x0262a, 0x0262a,),  # Star And Crescent
+        (0x0262e, 0x0262f,),  # Peace Symbol            ..Yin Yang
+        (0x02638, 0x0263a,),  # Wheel Of Dharma         ..White Smiling Face
+        (0x02640, 0x02640,),  # Female Sign
+        (0x02642, 0x02642,),  # Male Sign
+        (0x0265f, 0x02660,),  # Black Chess Pawn        ..Black Spade Suit
+        (0x02663, 0x02663,),  # Black Club Suit
+        (0x02665, 0x02666,),  # Black Heart Suit        ..Black Diamond Suit
+        (0x02668, 0x02668,),  # Hot Springs
+        (0x0267b, 0x0267b,),  # Black Universal Recycling Symbol
+        (0x0267e, 0x0267e,),  # Permanent Paper Sign
+        (0x02692, 0x02692,),  # Hammer And Pick
+        (0x02694, 0x02697,),  # Crossed Swords          ..Alembic
+        (0x02699, 0x02699,),  # Gear
+        (0x0269b, 0x0269c,),  # Atom Symbol             ..Fleur-de-lis
+        (0x026a0, 0x026a0,),  # Warning Sign
+        (0x026a7, 0x026a7,),  # Male With Stroke And Male And Female Sign
+        (0x026b0, 0x026b1,),  # Coffin                  ..Funeral Urn
+        (0x026c8, 0x026c8,),  # Thunder Cloud And Rain
+        (0x026cf, 0x026cf,),  # Pick
+        (0x026d1, 0x026d1,),  # Helmet With White Cross
+        (0x026d3, 0x026d3,),  # Chains
+        (0x026e9, 0x026e9,),  # Shinto Shrine
+        (0x026f0, 0x026f1,),  # Mountain                ..Umbrella On Ground
+        (0x026f4, 0x026f4,),  # Ferry
+        (0x026f7, 0x026f9,),  # Skier                   ..Person With Ball
+        (0x02702, 0x02702,),  # Black Scissors
+        (0x02708, 0x02709,),  # Airplane                ..Envelope
+        (0x0270c, 0x0270d,),  # Victory Hand            ..Writing Hand
+        (0x0270f, 0x0270f,),  # Pencil
+        (0x02712, 0x02712,),  # Black Nib
+        (0x02714, 0x02714,),  # Heavy Check Mark
+        (0x02716, 0x02716,),  # Heavy Multiplication X
+        (0x0271d, 0x0271d,),  # Latin Cross
+        (0x02721, 0x02721,),  # Star Of David
+        (0x02733, 0x02734,),  # Eight Spoked Asterisk   ..Eight Pointed Black Star
+        (0x02744, 0x02744,),  # Snowflake
+        (0x02747, 0x02747,),  # Sparkle
+        (0x02763, 0x02764,),  # Heavy Heart Exclamation ..Heavy Black Heart
+        (0x027a1, 0x027a1,),  # Black Rightwards Arrow
+        (0x02934, 0x02935,),  # Arrow Pointing Rightward..Arrow Pointing Rightward
+        (0x02b05, 0x02b07,),  # Leftwards Black Arrow   ..Downwards Black Arrow
+        (0x1f170, 0x1f171,),  # Negative Squared Latin C..Negative Squared Latin C
+        (0x1f17e, 0x1f17f,),  # Negative Squared Latin C..Negative Squared Latin C
+        (0x1f321, 0x1f321,),  # Thermometer
+        (0x1f324, 0x1f32c,),  # White Sun With Small Clo..Wind Blowing Face
+        (0x1f336, 0x1f336,),  # Hot Pepper
+        (0x1f37d, 0x1f37d,),  # Fork And Knife With Plate
+        (0x1f396, 0x1f397,),  # Military Medal          ..Reminder Ribbon
+        (0x1f399, 0x1f39b,),  # Studio Microphone       ..Control Knobs
+        (0x1f39e, 0x1f39f,),  # Film Frames             ..Admission Tickets
+        (0x1f3cb, 0x1f3ce,),  # Weight Lifter           ..Racing Car
+        (0x1f3d4, 0x1f3df,),  # Snow Capped Mountain    ..Stadium
+        (0x1f3f3, 0x1f3f3,),  # Waving White Flag
+        (0x1f3f5, 0x1f3f5,),  # Rosette
+        (0x1f3f7, 0x1f3f7,),  # Label
+        (0x1f43f, 0x1f43f,),  # Chipmunk
+        (0x1f441, 0x1f441,),  # Eye
+        (0x1f4fd, 0x1f4fd,),  # Film Projector
+        (0x1f549, 0x1f54a,),  # Om Symbol               ..Dove Of Peace
+        (0x1f56f, 0x1f570,),  # Candle                  ..Mantelpiece Clock
+        (0x1f573, 0x1f579,),  # Hole                    ..Joystick
+        (0x1f587, 0x1f587,),  # Linked Paperclips
+        (0x1f58a, 0x1f58d,),  # Lower Left Ballpoint Pen..Lower Left Crayon
+        (0x1f590, 0x1f590,),  # Raised Hand With Fingers Splayed
+        (0x1f5a5, 0x1f5a5,),  # Desktop Computer
+        (0x1f5a8, 0x1f5a8,),  # Printer
+        (0x1f5b1, 0x1f5b2,),  # Three Button Mouse      ..Trackball
+        (0x1f5bc, 0x1f5bc,),  # Frame With Picture
+        (0x1f5c2, 0x1f5c4,),  # Card Index Dividers     ..File Cabinet
+        (0x1f5d1, 0x1f5d3,),  # Wastebasket             ..Spiral Calendar Pad
+        (0x1f5dc, 0x1f5de,),  # Compression             ..Rolled-up Newspaper
+        (0x1f5e1, 0x1f5e1,),  # Dagger Knife
+        (0x1f5e3, 0x1f5e3,),  # Speaking Head In Silhouette
+        (0x1f5e8, 0x1f5e8,),  # Left Speech Bubble
+        (0x1f5ef, 0x1f5ef,),  # Right Anger Bubble
+        (0x1f5f3, 0x1f5f3,),  # Ballot Box With Ballot
+        (0x1f5fa, 0x1f5fa,),  # World Map
+        (0x1f6cb, 0x1f6cb,),  # Couch And Lamp
+        (0x1f6cd, 0x1f6cf,),  # Shopping Bags           ..Bed
+        (0x1f6e0, 0x1f6e5,),  # Hammer And Wrench       ..Motor Boat
+        (0x1f6e9, 0x1f6e9,),  # Small Airplane
+        (0x1f6f0, 0x1f6f0,),  # Satellite
+        (0x1f6f3, 0x1f6f3,),  # Passenger Ship
+    ),
+}

llava_next/lib/python3.10/site-packages/wcwidth/wcwidth.py

@@ -0,0 +1,345 @@
+"""
+This is a python implementation of wcwidth() and wcswidth().
+
+https://github.com/jquast/wcwidth
+
+from Markus Kuhn's C code, retrieved from:
+
+    http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+
+This is an implementation of wcwidth() and wcswidth() (defined in
+IEEE Std 1002.1-2001) for Unicode.
+
+http://www.opengroup.org/onlinepubs/007904975/functions/wcwidth.html
+http://www.opengroup.org/onlinepubs/007904975/functions/wcswidth.html
+
+In fixed-width output devices, Latin characters all occupy a single
+"cell" position of equal width, whereas ideographic CJK characters
+occupy two such cells. Interoperability between terminal-line
+applications and (teletype-style) character terminals using the
+UTF-8 encoding requires agreement on which character should advance
+the cursor by how many cell positions. No established formal
+standards exist at present on which Unicode character shall occupy
+how many cell positions on character terminals. These routines are
+a first attempt of defining such behavior based on simple rules
+applied to data provided by the Unicode Consortium.
+
+For some graphical characters, the Unicode standard explicitly
+defines a character-cell width via the definition of the East Asian
+FullWidth (F), Wide (W), Half-width (H), and Narrow (Na) classes.
+In all these cases, there is no ambiguity about which width a
+terminal shall use. For characters in the East Asian Ambiguous (A)
+class, the width choice depends purely on a preference of backward
+compatibility with either historic CJK or Western practice.
+Choosing single-width for these characters is easy to justify as
+the appropriate long-term solution, as the CJK practice of
+displaying these characters as double-width comes from historic
+implementation simplicity (8-bit encoded characters were displayed
+single-width and 16-bit ones double-width, even for Greek,
+Cyrillic, etc.) and not any typographic considerations.
+
+Much less clear is the choice of width for the Not East Asian
+(Neutral) class. Existing practice does not dictate a width for any
+of these characters. It would nevertheless make sense
+typographically to allocate two character cells to characters such
+as for instance EM SPACE or VOLUME INTEGRAL, which cannot be
+represented adequately with a single-width glyph. The following
+routines at present merely assign a single-cell width to all
+neutral characters, in the interest of simplicity. This is not
+entirely satisfactory and should be reconsidered before
+establishing a formal standard in this area. At the moment, the
+decision which Not East Asian (Neutral) characters should be
+represented by double-width glyphs cannot yet be answered by
+applying a simple rule from the Unicode database content. Setting
+up a proper standard for the behavior of UTF-8 character terminals
+will require a careful analysis not only of each Unicode character,
+but also of each presentation form, something the author of these
+routines has avoided to do so far.
+
+http://www.unicode.org/unicode/reports/tr11/
+
+Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+"""
+from __future__ import division
+
+# std imports
+import os
+import sys
+import warnings
+
+# local
+from .table_vs16 import VS16_NARROW_TO_WIDE
+from .table_wide import WIDE_EASTASIAN
+from .table_zero import ZERO_WIDTH
+from .unicode_versions import list_versions
+
+try:
+    # std imports
+    from functools import lru_cache
+except ImportError:
+    # lru_cache was added in Python 3.2
+    # 3rd party
+    from backports.functools_lru_cache import lru_cache
+
+# global cache
+_PY3 = sys.version_info[0] >= 3
+
+
+def _bisearch(ucs, table):
+    """
+    Auxiliary function for binary search in interval table.
+
+    :arg int ucs: Ordinal value of unicode character.
+    :arg list table: List of starting and ending ranges of ordinal values,
+        in form of ``[(start, end), ...]``.
+    :rtype: int
+    :returns: 1 if ordinal value ucs is found within lookup table, else 0.
+    """
+    lbound = 0
+    ubound = len(table) - 1
+
+    if ucs < table[0][0] or ucs > table[ubound][1]:
+        return 0
+    while ubound >= lbound:
+        mid = (lbound + ubound) // 2
+        if ucs > table[mid][1]:
+            lbound = mid + 1
+        elif ucs < table[mid][0]:
+            ubound = mid - 1
+        else:
+            return 1
+
+    return 0
+
+
+@lru_cache(maxsize=1000)
+def wcwidth(wc, unicode_version='auto'):
+    r"""
+    Given one Unicode character, return its printable length on a terminal.
+
+    :param str wc: A single Unicode character.
+    :param str unicode_version: A Unicode version number, such as
+        ``'6.0.0'``. A list of version levels suported by wcwidth
+        is returned by :func:`list_versions`.
+
+        Any version string may be specified without error -- the nearest
+        matching version is selected.  When ``latest`` (default), the
+        highest Unicode version level is used.
+    :return: The width, in cells, necessary to display the character of
+        Unicode string character, ``wc``.  Returns 0 if the ``wc`` argument has
+        no printable effect on a terminal (such as NUL '\0'), -1 if ``wc`` is
+        not printable, or has an indeterminate effect on the terminal, such as
+        a control character.  Otherwise, the number of column positions the
+        character occupies on a graphic terminal (1 or 2) is returned.
+    :rtype: int
+
+    See :ref:`Specification` for details of cell measurement.
+    """
+    ucs = ord(wc) if wc else 0
+
+    # small optimization: early return of 1 for printable ASCII, this provides
+    # approximately 40% performance improvement for mostly-ascii documents, with
+    # less than 1% impact to others.
+    if 32 <= ucs < 0x7f:
+        return 1
+
+    # C0/C1 control characters are -1 for compatibility with POSIX-like calls
+    if ucs and ucs < 32 or 0x07F <= ucs < 0x0A0:
+        return -1
+
+    _unicode_version = _wcmatch_version(unicode_version)
+
+    # Zero width
+    if _bisearch(ucs, ZERO_WIDTH[_unicode_version]):
+        return 0
+
+    # 1 or 2 width
+    return 1 + _bisearch(ucs, WIDE_EASTASIAN[_unicode_version])
+
+
+def wcswidth(pwcs, n=None, unicode_version='auto'):
+    """
+    Given a unicode string, return its printable length on a terminal.
+
+    :param str pwcs: Measure width of given unicode string.
+    :param int n: When ``n`` is None (default), return the length of the entire
+        string, otherwise only the first ``n`` characters are measured. This
+        argument exists only for compatibility with the C POSIX function
+        signature. It is suggested instead to use python's string slicing
+        capability, ``wcswidth(pwcs[:n])``
+    :param str unicode_version: An explicit definition of the unicode version
+        level to use for determination, may be ``auto`` (default), which uses
+        the Environment Variable, ``UNICODE_VERSION`` if defined, or the latest
+        available unicode version, otherwise.
+    :rtype: int
+    :returns: The width, in cells, needed to display the first ``n`` characters
+        of the unicode string ``pwcs``.  Returns ``-1`` for C0 and C1 control
+        characters!
+
+    See :ref:`Specification` for details of cell measurement.
+    """
+    # this 'n' argument is a holdover for POSIX function
+    _unicode_version = None
+    end = len(pwcs) if n is None else n
+    width = 0
+    idx = 0
+    last_measured_char = None
+    while idx < end:
+        char = pwcs[idx]
+        if char == u'\u200D':
+            # Zero Width Joiner, do not measure this or next character
+            idx += 2
+            continue
+        if char == u'\uFE0F' and last_measured_char:
+            # on variation selector 16 (VS16) following another character,
+            # conditionally add '1' to the measured width if that character is
+            # known to be converted from narrow to wide by the VS16 character.
+            if _unicode_version is None:
+                _unicode_version = _wcversion_value(_wcmatch_version(unicode_version))
+            if _unicode_version >= (9, 0, 0):
+                width += _bisearch(ord(last_measured_char), VS16_NARROW_TO_WIDE["9.0.0"])
+                last_measured_char = None
+            idx += 1
+            continue
+        # measure character at current index
+        wcw = wcwidth(char, unicode_version)
+        if wcw < 0:
+            # early return -1 on C0 and C1 control characters
+            return wcw
+        if wcw > 0:
+            # track last character measured to contain a cell, so that
+            # subsequent VS-16 modifiers may be understood
+            last_measured_char = char
+        width += wcw
+        idx += 1
+    return width
+
+
+@lru_cache(maxsize=128)
+def _wcversion_value(ver_string):
+    """
+    Integer-mapped value of given dotted version string.
+
+    :param str ver_string: Unicode version string, of form ``n.n.n``.
+    :rtype: tuple(int)
+    :returns: tuple of digit tuples, ``tuple(int, [...])``.
+    """
+    retval = tuple(map(int, (ver_string.split('.'))))
+    return retval
+
+
+@lru_cache(maxsize=8)
+def _wcmatch_version(given_version):
+    """
+    Return nearest matching supported Unicode version level.
+
+    If an exact match is not determined, the nearest lowest version level is
+    returned after a warning is emitted.  For example, given supported levels
+    ``4.1.0`` and ``5.0.0``, and a version string of ``4.9.9``, then ``4.1.0``
+    is selected and returned:
+
+    >>> _wcmatch_version('4.9.9')
+    '4.1.0'
+    >>> _wcmatch_version('8.0')
+    '8.0.0'
+    >>> _wcmatch_version('1')
+    '4.1.0'
+
+    :param str given_version: given version for compare, may be ``auto``
+        (default), to select Unicode Version from Environment Variable,
+        ``UNICODE_VERSION``. If the environment variable is not set, then the
+        latest is used.
+    :rtype: str
+    :returns: unicode string, or non-unicode ``str`` type for python 2
+        when given ``version`` is also type ``str``.
+    """
+    # Design note: the choice to return the same type that is given certainly
+    # complicates it for python 2 str-type, but allows us to define an api that
+    # uses 'string-type' for unicode version level definitions, so all of our
+    # example code works with all versions of python.
+    #
+    # That, along with the string-to-numeric and comparisons of earliest,
+    # latest, matching, or nearest, greatly complicates this function.
+    # Performance is somewhat curbed by memoization.
+    _return_str = not _PY3 and isinstance(given_version, str)
+
+    if _return_str:
+        # avoid list-comprehension to work around a coverage issue:
+        # https://github.com/nedbat/coveragepy/issues/753
+        unicode_versions = list(map(lambda ucs: ucs.encode(), list_versions()))
+    else:
+        unicode_versions = list_versions()
+    latest_version = unicode_versions[-1]
+
+    if given_version in (u'auto', 'auto'):
+        given_version = os.environ.get(
+            'UNICODE_VERSION',
+            'latest' if not _return_str else latest_version.encode())
+
+    if given_version in (u'latest', 'latest'):
+        # default match, when given as 'latest', use the most latest unicode
+        # version specification level supported.
+        return latest_version if not _return_str else latest_version.encode()
+
+    if given_version in unicode_versions:
+        # exact match, downstream has specified an explicit matching version
+        # matching any value of list_versions().
+        return given_version if not _return_str else given_version.encode()
+
+    # The user's version is not supported by ours. We return the newest unicode
+    # version level that we support below their given value.
+    try:
+        cmp_given = _wcversion_value(given_version)
+
+    except ValueError:
+        # submitted value raises ValueError in int(), warn and use latest.
+        warnings.warn("UNICODE_VERSION value, {given_version!r}, is invalid. "
+                      "Value should be in form of `integer[.]+', the latest "
+                      "supported unicode version {latest_version!r} has been "
+                      "inferred.".format(given_version=given_version,
+                                         latest_version=latest_version))
+        return latest_version if not _return_str else latest_version.encode()
+
+    # given version is less than any available version, return earliest
+    # version.
+    earliest_version = unicode_versions[0]
+    cmp_earliest_version = _wcversion_value(earliest_version)
+
+    if cmp_given <= cmp_earliest_version:
+        # this probably isn't what you wanted, the oldest wcwidth.c you will
+        # find in the wild is likely version 5 or 6, which we both support,
+        # but it's better than not saying anything at all.
+        warnings.warn("UNICODE_VERSION value, {given_version!r}, is lower "
+                      "than any available unicode version. Returning lowest "
+                      "version level, {earliest_version!r}".format(
+                          given_version=given_version,
+                          earliest_version=earliest_version))
+        return earliest_version if not _return_str else earliest_version.encode()
+
+    # create list of versions which are less than our equal to given version,
+    # and return the tail value, which is the highest level we may support,
+    # or the latest value we support, when completely unmatched or higher
+    # than any supported version.
+    #
+    # function will never complete, always returns.
+    for idx, unicode_version in enumerate(unicode_versions):
+        # look ahead to next value
+        try:
+            cmp_next_version = _wcversion_value(unicode_versions[idx + 1])
+        except IndexError:
+            # at end of list, return latest version
+            return latest_version if not _return_str else latest_version.encode()
+
+        # Maybe our given version has less parts, as in tuple(8, 0), than the
+        # next compare version tuple(8, 0, 0). Test for an exact match by
+        # comparison of only the leading dotted piece(s): (8, 0) == (8, 0).
+        if cmp_given == cmp_next_version[:len(cmp_given)]:
+            return unicode_versions[idx + 1]
+
+        # Or, if any next value is greater than our given support level
+        # version, return the current value in index.  Even though it must
+        # be less than the given value, its our closest possible match. That
+        # is, 4.1 is returned for given 4.9.9, where 4.1 and 5.0 are available.
+        if cmp_next_version > cmp_given:
+            return unicode_version
+    assert False, ("Code path unreachable", given_version, unicode_versions)  # pragma: no cover

parrot/lib/python3.10/site-packages/aiofiles/tempfile/__init__.py

@@ -0,0 +1,357 @@
+import asyncio
+from functools import partial, singledispatch
+from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOBase
+from tempfile import NamedTemporaryFile as syncNamedTemporaryFile
+from tempfile import SpooledTemporaryFile as syncSpooledTemporaryFile
+from tempfile import TemporaryDirectory as syncTemporaryDirectory
+from tempfile import TemporaryFile as syncTemporaryFile
+from tempfile import _TemporaryFileWrapper as syncTemporaryFileWrapper
+
+from ..base import AiofilesContextManager
+from ..threadpool.binary import AsyncBufferedIOBase, AsyncBufferedReader, AsyncFileIO
+from ..threadpool.text import AsyncTextIOWrapper
+from .temptypes import AsyncSpooledTemporaryFile, AsyncTemporaryDirectory
+import sys
+
+__all__ = [
+    "NamedTemporaryFile",
+    "TemporaryFile",
+    "SpooledTemporaryFile",
+    "TemporaryDirectory",
+]
+
+
+# ================================================================
+# Public methods for async open and return of temp file/directory
+# objects with async interface
+# ================================================================
+if sys.version_info >= (3, 12):
+
+    def NamedTemporaryFile(
+        mode="w+b",
+        buffering=-1,
+        encoding=None,
+        newline=None,
+        suffix=None,
+        prefix=None,
+        dir=None,
+        delete=True,
+        delete_on_close=True,
+        loop=None,
+        executor=None,
+    ):
+        """Async open a named temporary file"""
+        return AiofilesContextManager(
+            _temporary_file(
+                named=True,
+                mode=mode,
+                buffering=buffering,
+                encoding=encoding,
+                newline=newline,
+                suffix=suffix,
+                prefix=prefix,
+                dir=dir,
+                delete=delete,
+                delete_on_close=delete_on_close,
+                loop=loop,
+                executor=executor,
+            )
+        )
+
+else:
+
+    def NamedTemporaryFile(
+        mode="w+b",
+        buffering=-1,
+        encoding=None,
+        newline=None,
+        suffix=None,
+        prefix=None,
+        dir=None,
+        delete=True,
+        loop=None,
+        executor=None,
+    ):
+        """Async open a named temporary file"""
+        return AiofilesContextManager(
+            _temporary_file(
+                named=True,
+                mode=mode,
+                buffering=buffering,
+                encoding=encoding,
+                newline=newline,
+                suffix=suffix,
+                prefix=prefix,
+                dir=dir,
+                delete=delete,
+                loop=loop,
+                executor=executor,
+            )
+        )
+
+
+def TemporaryFile(
+    mode="w+b",
+    buffering=-1,
+    encoding=None,
+    newline=None,
+    suffix=None,
+    prefix=None,
+    dir=None,
+    loop=None,
+    executor=None,
+):
+    """Async open an unnamed temporary file"""
+    return AiofilesContextManager(
+        _temporary_file(
+            named=False,
+            mode=mode,
+            buffering=buffering,
+            encoding=encoding,
+            newline=newline,
+            suffix=suffix,
+            prefix=prefix,
+            dir=dir,
+            loop=loop,
+            executor=executor,
+        )
+    )
+
+
+def SpooledTemporaryFile(
+    max_size=0,
+    mode="w+b",
+    buffering=-1,
+    encoding=None,
+    newline=None,
+    suffix=None,
+    prefix=None,
+    dir=None,
+    loop=None,
+    executor=None,
+):
+    """Async open a spooled temporary file"""
+    return AiofilesContextManager(
+        _spooled_temporary_file(
+            max_size=max_size,
+            mode=mode,
+            buffering=buffering,
+            encoding=encoding,
+            newline=newline,
+            suffix=suffix,
+            prefix=prefix,
+            dir=dir,
+            loop=loop,
+            executor=executor,
+        )
+    )
+
+
+def TemporaryDirectory(suffix=None, prefix=None, dir=None, loop=None, executor=None):
+    """Async open a temporary directory"""
+    return AiofilesContextManagerTempDir(
+        _temporary_directory(
+            suffix=suffix, prefix=prefix, dir=dir, loop=loop, executor=executor
+        )
+    )
+
+
+# =========================================================
+# Internal coroutines to open new temp files/directories
+# =========================================================
+if sys.version_info >= (3, 12):
+
+    async def _temporary_file(
+        named=True,
+        mode="w+b",
+        buffering=-1,
+        encoding=None,
+        newline=None,
+        suffix=None,
+        prefix=None,
+        dir=None,
+        delete=True,
+        delete_on_close=True,
+        loop=None,
+        executor=None,
+        max_size=0,
+    ):
+        """Async method to open a temporary file with async interface"""
+        if loop is None:
+            loop = asyncio.get_running_loop()
+
+        if named:
+            cb = partial(
+                syncNamedTemporaryFile,
+                mode=mode,
+                buffering=buffering,
+                encoding=encoding,
+                newline=newline,
+                suffix=suffix,
+                prefix=prefix,
+                dir=dir,
+                delete=delete,
+                delete_on_close=delete_on_close,
+            )
+        else:
+            cb = partial(
+                syncTemporaryFile,
+                mode=mode,
+                buffering=buffering,
+                encoding=encoding,
+                newline=newline,
+                suffix=suffix,
+                prefix=prefix,
+                dir=dir,
+            )
+
+        f = await loop.run_in_executor(executor, cb)
+
+        # Wrap based on type of underlying IO object
+        if type(f) is syncTemporaryFileWrapper:
+            # _TemporaryFileWrapper was used (named files)
+            result = wrap(f.file, f, loop=loop, executor=executor)
+            result._closer = f._closer
+            return result
+        else:
+            # IO object was returned directly without wrapper
+            return wrap(f, f, loop=loop, executor=executor)
+
+else:
+
+    async def _temporary_file(
+        named=True,
+        mode="w+b",
+        buffering=-1,
+        encoding=None,
+        newline=None,
+        suffix=None,
+        prefix=None,
+        dir=None,
+        delete=True,
+        loop=None,
+        executor=None,
+        max_size=0,
+    ):
+        """Async method to open a temporary file with async interface"""
+        if loop is None:
+            loop = asyncio.get_running_loop()
+
+        if named:
+            cb = partial(
+                syncNamedTemporaryFile,
+                mode=mode,
+                buffering=buffering,
+                encoding=encoding,
+                newline=newline,
+                suffix=suffix,
+                prefix=prefix,
+                dir=dir,
+                delete=delete,
+            )
+        else:
+            cb = partial(
+                syncTemporaryFile,
+                mode=mode,
+                buffering=buffering,
+                encoding=encoding,
+                newline=newline,
+                suffix=suffix,
+                prefix=prefix,
+                dir=dir,
+            )
+
+        f = await loop.run_in_executor(executor, cb)
+
+        # Wrap based on type of underlying IO object
+        if type(f) is syncTemporaryFileWrapper:
+            # _TemporaryFileWrapper was used (named files)
+            result = wrap(f.file, f, loop=loop, executor=executor)
+            # add delete property
+            result.delete = f.delete
+            return result
+        else:
+            # IO object was returned directly without wrapper
+            return wrap(f, f, loop=loop, executor=executor)
+
+
+async def _spooled_temporary_file(
+    max_size=0,
+    mode="w+b",
+    buffering=-1,
+    encoding=None,
+    newline=None,
+    suffix=None,
+    prefix=None,
+    dir=None,
+    loop=None,
+    executor=None,
+):
+    """Open a spooled temporary file with async interface"""
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    cb = partial(
+        syncSpooledTemporaryFile,
+        max_size=max_size,
+        mode=mode,
+        buffering=buffering,
+        encoding=encoding,
+        newline=newline,
+        suffix=suffix,
+        prefix=prefix,
+        dir=dir,
+    )
+
+    f = await loop.run_in_executor(executor, cb)
+
+    # Single interface provided by SpooledTemporaryFile for all modes
+    return AsyncSpooledTemporaryFile(f, loop=loop, executor=executor)
+
+
+async def _temporary_directory(
+    suffix=None, prefix=None, dir=None, loop=None, executor=None
+):
+    """Async method to open a temporary directory with async interface"""
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    cb = partial(syncTemporaryDirectory, suffix, prefix, dir)
+    f = await loop.run_in_executor(executor, cb)
+
+    return AsyncTemporaryDirectory(f, loop=loop, executor=executor)
+
+
+class AiofilesContextManagerTempDir(AiofilesContextManager):
+    """With returns the directory location, not the object (matching sync lib)"""
+
+    async def __aenter__(self):
+        self._obj = await self._coro
+        return self._obj.name
+
+
+@singledispatch
+def wrap(base_io_obj, file, *, loop=None, executor=None):
+    """Wrap the object with interface based on type of underlying IO"""
+    raise TypeError("Unsupported IO type: {}".format(base_io_obj))
+
+
+@wrap.register(TextIOBase)
+def _(base_io_obj, file, *, loop=None, executor=None):
+    return AsyncTextIOWrapper(file, loop=loop, executor=executor)
+
+
+@wrap.register(BufferedWriter)
+def _(base_io_obj, file, *, loop=None, executor=None):
+    return AsyncBufferedIOBase(file, loop=loop, executor=executor)
+
+
+@wrap.register(BufferedReader)
+@wrap.register(BufferedRandom)
+def _(base_io_obj, file, *, loop=None, executor=None):
+    return AsyncBufferedReader(file, loop=loop, executor=executor)
+
+
+@wrap.register(FileIO)
+def _(base_io_obj, file, *, loop=None, executor=None):
+    return AsyncFileIO(file, loop=loop, executor=executor)

parrot/lib/python3.10/site-packages/aiofiles/tempfile/temptypes.py

@@ -0,0 +1,69 @@
+"""Async wrappers for spooled temp files and temp directory objects"""
+from functools import partial
+
+from ..base import AsyncBase
+from ..threadpool.utils import (
+    cond_delegate_to_executor,
+    delegate_to_executor,
+    proxy_property_directly,
+)
+
+
+@delegate_to_executor("fileno", "rollover")
+@cond_delegate_to_executor(
+    "close",
+    "flush",
+    "isatty",
+    "read",
+    "readline",
+    "readlines",
+    "seek",
+    "tell",
+    "truncate",
+)
+@proxy_property_directly("closed", "encoding", "mode", "name", "newlines")
+class AsyncSpooledTemporaryFile(AsyncBase):
+    """Async wrapper for SpooledTemporaryFile class"""
+
+    async def _check(self):
+        if self._file._rolled:
+            return
+        max_size = self._file._max_size
+        if max_size and self._file.tell() > max_size:
+            await self.rollover()
+
+    async def write(self, s):
+        """Implementation to anticipate rollover"""
+        if self._file._rolled:
+            cb = partial(self._file.write, s)
+            return await self._loop.run_in_executor(self._executor, cb)
+        else:
+            file = self._file._file  # reference underlying base IO object
+            rv = file.write(s)
+            await self._check()
+            return rv
+
+    async def writelines(self, iterable):
+        """Implementation to anticipate rollover"""
+        if self._file._rolled:
+            cb = partial(self._file.writelines, iterable)
+            return await self._loop.run_in_executor(self._executor, cb)
+        else:
+            file = self._file._file  # reference underlying base IO object
+            rv = file.writelines(iterable)
+            await self._check()
+            return rv
+
+
+@delegate_to_executor("cleanup")
+@proxy_property_directly("name")
+class AsyncTemporaryDirectory:
+    """Async wrapper for TemporaryDirectory class"""
+
+    def __init__(self, file, loop, executor):
+        self._file = file
+        self._loop = loop
+        self._executor = executor
+
+    async def close(self):
+        await self.cleanup()

parrot/lib/python3.10/site-packages/sympy/abc.py

@@ -0,0 +1,111 @@
+"""
+This module exports all latin and greek letters as Symbols, so you can
+conveniently do
+
+    >>> from sympy.abc import x, y
+
+instead of the slightly more clunky-looking
+
+    >>> from sympy import symbols
+    >>> x, y = symbols('x y')
+
+Caveats
+=======
+
+1. As of the time of writing this, the names ``O``, ``S``, ``I``, ``N``,
+``E``, and ``Q`` are colliding with names defined in SymPy. If you import them
+from both ``sympy.abc`` and ``sympy``, the second import will "win".
+This is an issue only for * imports, which should only be used for short-lived
+code such as interactive sessions and throwaway scripts that do not survive
+until the next SymPy upgrade, where ``sympy`` may contain a different set of
+names.
+
+2. This module does not define symbol names on demand, i.e.
+``from sympy.abc import foo`` will be reported as an error because
+``sympy.abc`` does not contain the name ``foo``. To get a symbol named ``foo``,
+you still need to use ``Symbol('foo')`` or ``symbols('foo')``.
+You can freely mix usage of ``sympy.abc`` and ``Symbol``/``symbols``, though
+sticking with one and only one way to get the symbols does tend to make the code
+more readable.
+
+The module also defines some special names to help detect which names clash
+with the default SymPy namespace.
+
+``_clash1`` defines all the single letter variables that clash with
+SymPy objects; ``_clash2`` defines the multi-letter clashing symbols;
+and ``_clash`` is the union of both. These can be passed for ``locals``
+during sympification if one desires Symbols rather than the non-Symbol
+objects for those names.
+
+Examples
+========
+
+>>> from sympy import S
+>>> from sympy.abc import _clash1, _clash2, _clash
+>>> S("Q & C", locals=_clash1)
+C & Q
+>>> S('pi(x)', locals=_clash2)
+pi(x)
+>>> S('pi(C, Q)', locals=_clash)
+pi(C, Q)
+
+"""
+
+from typing import Any, Dict as tDict
+
+import string
+
+from .core import Symbol, symbols
+from .core.alphabets import greeks
+from sympy.parsing.sympy_parser import null
+
+##### Symbol definitions #####
+
+# Implementation note: The easiest way to avoid typos in the symbols()
+# parameter is to copy it from the left-hand side of the assignment.
+
+a, b, c, d, e, f, g, h, i, j = symbols('a, b, c, d, e, f, g, h, i, j')
+k, l, m, n, o, p, q, r, s, t = symbols('k, l, m, n, o, p, q, r, s, t')
+u, v, w, x, y, z = symbols('u, v, w, x, y, z')
+
+A, B, C, D, E, F, G, H, I, J = symbols('A, B, C, D, E, F, G, H, I, J')
+K, L, M, N, O, P, Q, R, S, T = symbols('K, L, M, N, O, P, Q, R, S, T')
+U, V, W, X, Y, Z = symbols('U, V, W, X, Y, Z')
+
+alpha, beta, gamma, delta = symbols('alpha, beta, gamma, delta')
+epsilon, zeta, eta, theta = symbols('epsilon, zeta, eta, theta')
+iota, kappa, lamda, mu = symbols('iota, kappa, lamda, mu')
+nu, xi, omicron, pi = symbols('nu, xi, omicron, pi')
+rho, sigma, tau, upsilon = symbols('rho, sigma, tau, upsilon')
+phi, chi, psi, omega = symbols('phi, chi, psi, omega')
+
+
+##### Clashing-symbols diagnostics #####
+
+# We want to know which names in SymPy collide with those in here.
+# This is mostly for diagnosing SymPy's namespace during SymPy development.
+
+_latin = list(string.ascii_letters)
+# QOSINE should not be imported as they clash; gamma, pi and zeta clash, too
+_greek = list(greeks) # make a copy, so we can mutate it
+# Note: We import lamda since lambda is a reserved keyword in Python
+_greek.remove("lambda")
+_greek.append("lamda")
+
+ns: tDict[str, Any] = {}
+exec('from sympy import *', ns)
+_clash1: tDict[str, Any] = {}
+_clash2: tDict[str, Any] = {}
+while ns:
+    _k, _ = ns.popitem()
+    if _k in _greek:
+        _clash2[_k] = null
+        _greek.remove(_k)
+    elif _k in _latin:
+        _clash1[_k] = null
+        _latin.remove(_k)
+_clash = {}
+_clash.update(_clash1)
+_clash.update(_clash2)
+
+del _latin, _greek, Symbol, _k, null

parrot/lib/python3.10/site-packages/sympy/conftest.py

@@ -0,0 +1,96 @@
+import sys
+
+sys._running_pytest = True  # type: ignore
+from sympy.external.importtools import version_tuple
+
+import pytest
+from sympy.core.cache import clear_cache, USE_CACHE
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.utilities.misc import ARCH
+import re
+
+try:
+    import hypothesis
+
+    hypothesis.settings.register_profile("sympy_hypothesis_profile", deadline=None)
+    hypothesis.settings.load_profile("sympy_hypothesis_profile")
+except ImportError:
+    raise ImportError(
+        "hypothesis is a required dependency to run the SymPy test suite. "
+        "Install it with 'pip install hypothesis' or 'conda install -c conda-forge hypothesis'"
+    )
+
+
+sp = re.compile(r"([0-9]+)/([1-9][0-9]*)")
+
+
+def process_split(config, items):
+    split = config.getoption("--split")
+    if not split:
+        return
+    m = sp.match(split)
+    if not m:
+        raise ValueError(
+            "split must be a string of the form a/b " "where a and b are ints."
+        )
+    i, t = map(int, m.groups())
+    start, end = (i - 1) * len(items) // t, i * len(items) // t
+
+    if i < t:
+        # remove elements from end of list first
+        del items[end:]
+    del items[:start]
+
+
+def pytest_report_header(config):
+    s = "architecture: %s\n" % ARCH
+    s += "cache:        %s\n" % USE_CACHE
+    version = ""
+    if GROUND_TYPES == "gmpy":
+        import gmpy2
+
+        version = gmpy2.version()
+    elif GROUND_TYPES == "flint":
+        try:
+            from flint import __version__
+        except ImportError:
+            version = "unknown"
+        else:
+            version = f'(python-flint=={__version__})'
+    s += "ground types: %s %s\n" % (GROUND_TYPES, version)
+    return s
+
+
+def pytest_terminal_summary(terminalreporter):
+    if terminalreporter.stats.get("error", None) or terminalreporter.stats.get(
+        "failed", None
+    ):
+        terminalreporter.write_sep(" ", "DO *NOT* COMMIT!", red=True, bold=True)
+
+
+def pytest_addoption(parser):
+    parser.addoption("--split", action="store", default="", help="split tests")
+
+
+def pytest_collection_modifyitems(config, items):
+    """pytest hook."""
+    # handle splits
+    process_split(config, items)
+
+
+@pytest.fixture(autouse=True, scope="module")
+def file_clear_cache():
+    clear_cache()
+
+
+@pytest.fixture(autouse=True, scope="module")
+def check_disabled(request):
+    if getattr(request.module, "disabled", False):
+        pytest.skip("test requirements not met.")
+    elif getattr(request.module, "ipython", False):
+        # need to check version and options for ipython tests
+        if (
+            version_tuple(pytest.__version__) < version_tuple("2.6.3")
+            and pytest.config.getvalue("-s") != "no"
+        ):
+            pytest.skip("run py.test with -s or upgrade to newer version.")

parrot/lib/python3.10/site-packages/sympy/discrete/__init__.py

@@ -0,0 +1,20 @@
+"""This module contains functions which operate on discrete sequences.
+
+Transforms - ``fft``, ``ifft``, ``ntt``, ``intt``, ``fwht``, ``ifwht``,
+            ``mobius_transform``, ``inverse_mobius_transform``
+
+Convolutions - ``convolution``, ``convolution_fft``, ``convolution_ntt``,
+            ``convolution_fwht``, ``convolution_subset``,
+            ``covering_product``, ``intersecting_product``
+"""
+
+from .transforms import (fft, ifft, ntt, intt, fwht, ifwht,
+    mobius_transform, inverse_mobius_transform)
+from .convolutions import convolution, covering_product, intersecting_product
+
+__all__ = [
+    'fft', 'ifft', 'ntt', 'intt', 'fwht', 'ifwht', 'mobius_transform',
+    'inverse_mobius_transform',
+
+    'convolution', 'covering_product', 'intersecting_product',
+]

parrot/lib/python3.10/site-packages/sympy/discrete/recurrences.py

@@ -0,0 +1,166 @@
+"""
+Recurrences
+"""
+
+from sympy.core import S, sympify
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import as_int
+
+
+def linrec(coeffs, init, n):
+    r"""
+    Evaluation of univariate linear recurrences of homogeneous type
+    having coefficients independent of the recurrence variable.
+
+    Parameters
+    ==========
+
+    coeffs : iterable
+        Coefficients of the recurrence
+    init : iterable
+        Initial values of the recurrence
+    n : Integer
+        Point of evaluation for the recurrence
+
+    Notes
+    =====
+
+    Let `y(n)` be the recurrence of given type, ``c`` be the sequence
+    of coefficients, ``b`` be the sequence of initial/base values of the
+    recurrence and ``k`` (equal to ``len(c)``) be the order of recurrence.
+    Then,
+
+    .. math :: y(n) = \begin{cases} b_n & 0 \le n < k \\
+        c_0 y(n-1) + c_1 y(n-2) + \cdots + c_{k-1} y(n-k) & n \ge k
+        \end{cases}
+
+    Let `x_0, x_1, \ldots, x_n` be a sequence and consider the transformation
+    that maps each polynomial `f(x)` to `T(f(x))` where each power `x^i` is
+    replaced by the corresponding value `x_i`. The sequence is then a solution
+    of the recurrence if and only if `T(x^i p(x)) = 0` for each `i \ge 0` where
+    `p(x) = x^k - c_0 x^(k-1) - \cdots - c_{k-1}` is the characteristic
+    polynomial.
+
+    Then `T(f(x)p(x)) = 0` for each polynomial `f(x)` (as it is a linear
+    combination of powers `x^i`). Now, if `x^n` is congruent to
+    `g(x) = a_0 x^0 + a_1 x^1 + \cdots + a_{k-1} x^{k-1}` modulo `p(x)`, then
+    `T(x^n) = x_n` is equal to
+    `T(g(x)) = a_0 x_0 + a_1 x_1 + \cdots + a_{k-1} x_{k-1}`.
+
+    Computation of `x^n`,
+    given `x^k = c_0 x^{k-1} + c_1 x^{k-2} + \cdots + c_{k-1}`
+    is performed using exponentiation by squaring (refer to [1_]) with
+    an additional reduction step performed to retain only first `k` powers
+    of `x` in the representation of `x^n`.
+
+    Examples
+    ========
+
+    >>> from sympy.discrete.recurrences import linrec
+    >>> from sympy.abc import x, y, z
+
+    >>> linrec(coeffs=[1, 1], init=[0, 1], n=10)
+    55
+
+    >>> linrec(coeffs=[1, 1], init=[x, y], n=10)
+    34*x + 55*y
+
+    >>> linrec(coeffs=[x, y], init=[0, 1], n=5)
+    x**2*y + x*(x**3 + 2*x*y) + y**2
+
+    >>> linrec(coeffs=[1, 2, 3, 0, 0, 4], init=[x, y, z], n=16)
+    13576*x + 5676*y + 2356*z
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Exponentiation_by_squaring
+    .. [2] https://en.wikipedia.org/w/index.php?title=Modular_exponentiation&section=6#Matrices
+
+    See Also
+    ========
+
+    sympy.polys.agca.extensions.ExtensionElement.__pow__
+
+    """
+
+    if not coeffs:
+        return S.Zero
+
+    if not iterable(coeffs):
+        raise TypeError("Expected a sequence of coefficients for"
+                        " the recurrence")
+
+    if not iterable(init):
+        raise TypeError("Expected a sequence of values for the initialization"
+                        " of the recurrence")
+
+    n = as_int(n)
+    if n < 0:
+        raise ValueError("Point of evaluation of recurrence must be a "
+                        "non-negative integer")
+
+    c = [sympify(arg) for arg in coeffs]
+    b = [sympify(arg) for arg in init]
+    k = len(c)
+
+    if len(b) > k:
+        raise TypeError("Count of initial values should not exceed the "
+                        "order of the recurrence")
+    else:
+        b += [S.Zero]*(k - len(b)) # remaining initial values default to zero
+
+    if n < k:
+        return b[n]
+    terms = [u*v for u, v in zip(linrec_coeffs(c, n), b)]
+    return sum(terms[:-1], terms[-1])
+
+
+def linrec_coeffs(c, n):
+    r"""
+    Compute the coefficients of n'th term in linear recursion
+    sequence defined by c.
+
+    `x^k = c_0 x^{k-1} + c_1 x^{k-2} + \cdots + c_{k-1}`.
+
+    It computes the coefficients by using binary exponentiation.
+    This function is used by `linrec` and `_eval_pow_by_cayley`.
+
+    Parameters
+    ==========
+
+    c = coefficients of the divisor polynomial
+    n = exponent of x, so dividend is x^n
+
+    """
+
+    k = len(c)
+
+    def _square_and_reduce(u, offset):
+        # squares `(u_0 + u_1 x + u_2 x^2 + \cdots + u_{k-1} x^k)` (and
+        # multiplies by `x` if offset is 1) and reduces the above result of
+        # length upto `2k` to `k` using the characteristic equation of the
+        # recurrence given by, `x^k = c_0 x^{k-1} + c_1 x^{k-2} + \cdots + c_{k-1}`
+
+        w = [S.Zero]*(2*len(u) - 1 + offset)
+        for i, p in enumerate(u):
+            for j, q in enumerate(u):
+                w[offset + i + j] += p*q
+
+        for j in range(len(w) - 1, k - 1, -1):
+            for i in range(k):
+                w[j - i - 1] += w[j]*c[i]
+
+        return w[:k]
+
+    def _final_coeffs(n):
+        # computes the final coefficient list - `cf` corresponding to the
+        # point at which recurrence is to be evalauted - `n`, such that,
+        # `y(n) = cf_0 y(k-1) + cf_1 y(k-2) + \cdots + cf_{k-1} y(0)`
+
+        if n < k:
+            return [S.Zero]*n + [S.One] + [S.Zero]*(k - n - 1)
+        else:
+            return _square_and_reduce(_final_coeffs(n // 2), n % 2)
+
+    return _final_coeffs(n)

parrot/lib/python3.10/site-packages/sympy/discrete/tests/test_convolutions.py

@@ -0,0 +1,392 @@
+from sympy.core.numbers import (E, Rational, pi)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core import S, symbols, I
+from sympy.discrete.convolutions import (
+    convolution, convolution_fft, convolution_ntt, convolution_fwht,
+    convolution_subset, covering_product, intersecting_product,
+    convolution_int)
+from sympy.testing.pytest import raises
+from sympy.abc import x, y
+
+def test_convolution():
+    # fft
+    a = [1, Rational(5, 3), sqrt(3), Rational(7, 5)]
+    b = [9, 5, 5, 4, 3, 2]
+    c = [3, 5, 3, 7, 8]
+    d = [1422, 6572, 3213, 5552]
+    e = [-1, Rational(5, 3), Rational(7, 5)]
+
+    assert convolution(a, b) == convolution_fft(a, b)
+    assert convolution(a, b, dps=9) == convolution_fft(a, b, dps=9)
+    assert convolution(a, d, dps=7) == convolution_fft(d, a, dps=7)
+    assert convolution(a, d[1:], dps=3) == convolution_fft(d[1:], a, dps=3)
+
+    # prime moduli of the form (m*2**k + 1), sequence length
+    # should be a divisor of 2**k
+    p = 7*17*2**23 + 1
+    q = 19*2**10 + 1
+
+    # ntt
+    assert convolution(d, b, prime=q) == convolution_ntt(b, d, prime=q)
+    assert convolution(c, b, prime=p) == convolution_ntt(b, c, prime=p)
+    assert convolution(d, c, prime=p) == convolution_ntt(c, d, prime=p)
+    raises(TypeError, lambda: convolution(b, d, dps=5, prime=q))
+    raises(TypeError, lambda: convolution(b, d, dps=6, prime=q))
+
+    # fwht
+    assert convolution(a, b, dyadic=True) == convolution_fwht(a, b)
+    assert convolution(a, b, dyadic=False) == convolution(a, b)
+    raises(TypeError, lambda: convolution(b, d, dps=2, dyadic=True))
+    raises(TypeError, lambda: convolution(b, d, prime=p, dyadic=True))
+    raises(TypeError, lambda: convolution(a, b, dps=2, dyadic=True))
+    raises(TypeError, lambda: convolution(b, c, prime=p, dyadic=True))
+
+    # subset
+    assert convolution(a, b, subset=True) == convolution_subset(a, b) == \
+            convolution(a, b, subset=True, dyadic=False) == \
+                convolution(a, b, subset=True)
+    assert convolution(a, b, subset=False) == convolution(a, b)
+    raises(TypeError, lambda: convolution(a, b, subset=True, dyadic=True))
+    raises(TypeError, lambda: convolution(c, d, subset=True, dps=6))
+    raises(TypeError, lambda: convolution(a, c, subset=True, prime=q))
+
+    # integer
+    assert convolution([0], [0]) == convolution_int([0], [0])
+    assert convolution(b, c) == convolution_int(b, c)
+
+    # rational
+    assert convolution([Rational(1,2)], [Rational(1,2)]) == [Rational(1, 4)]
+    assert convolution(b, e) == [-9, 10, Rational(239, 15), Rational(34, 3),
+                                 Rational(32, 3), Rational(43, 5), Rational(113, 15),
+                                 Rational(14, 5)]
+
+
+def test_cyclic_convolution():
+    # fft
+    a = [1, Rational(5, 3), sqrt(3), Rational(7, 5)]
+    b = [9, 5, 5, 4, 3, 2]
+
+    assert convolution([1, 2, 3], [4, 5, 6], cycle=0) == \
+            convolution([1, 2, 3], [4, 5, 6], cycle=5) == \
+                convolution([1, 2, 3], [4, 5, 6])
+
+    assert convolution([1, 2, 3], [4, 5, 6], cycle=3) == [31, 31, 28]
+
+    a = [Rational(1, 3), Rational(7, 3), Rational(5, 9), Rational(2, 7), Rational(5, 8)]
+    b = [Rational(3, 5), Rational(4, 7), Rational(7, 8), Rational(8, 9)]
+
+    assert convolution(a, b, cycle=0) == \
+            convolution(a, b, cycle=len(a) + len(b) - 1)
+
+    assert convolution(a, b, cycle=4) == [Rational(87277, 26460), Rational(30521, 11340),
+                            Rational(11125, 4032), Rational(3653, 1080)]
+
+    assert convolution(a, b, cycle=6) == [Rational(20177, 20160), Rational(676, 315), Rational(47, 24),
+                            Rational(3053, 1080), Rational(16397, 5292), Rational(2497, 2268)]
+
+    assert convolution(a, b, cycle=9) == \
+                convolution(a, b, cycle=0) + [S.Zero]
+
+    # ntt
+    a = [2313, 5323532, S(3232), 42142, 42242421]
+    b = [S(33456), 56757, 45754, 432423]
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=0) == \
+            convolution(a, b, prime=19*2**10 + 1, cycle=8) == \
+                convolution(a, b, prime=19*2**10 + 1)
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=5) == [96, 17146, 2664,
+                                                                    15534, 3517]
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=7) == [4643, 3458, 1260,
+                                                        15534, 3517, 16314, 13688]
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=9) == \
+            convolution(a, b, prime=19*2**10 + 1) + [0]
+
+    # fwht
+    u, v, w, x, y = symbols('u v w x y')
+    p, q, r, s, t = symbols('p q r s t')
+    c = [u, v, w, x, y]
+    d = [p, q, r, s, t]
+
+    assert convolution(a, b, dyadic=True, cycle=3) == \
+                        [2499522285783, 19861417974796, 4702176579021]
+
+    assert convolution(a, b, dyadic=True, cycle=5) == [2718149225143,
+            2114320852171, 20571217906407, 246166418903, 1413262436976]
+
+    assert convolution(c, d, dyadic=True, cycle=4) == \
+            [p*u + p*y + q*v + r*w + s*x + t*u + t*y,
+             p*v + q*u + q*y + r*x + s*w + t*v,
+             p*w + q*x + r*u + r*y + s*v + t*w,
+             p*x + q*w + r*v + s*u + s*y + t*x]
+
+    assert convolution(c, d, dyadic=True, cycle=6) == \
+            [p*u + q*v + r*w + r*y + s*x + t*w + t*y,
+             p*v + q*u + r*x + s*w + s*y + t*x,
+             p*w + q*x + r*u + s*v,
+             p*x + q*w + r*v + s*u,
+             p*y + t*u,
+             q*y + t*v]
+
+    # subset
+    assert convolution(a, b, subset=True, cycle=7) == [18266671799811,
+                    178235365533, 213958794, 246166418903, 1413262436976,
+                    2397553088697, 1932759730434]
+
+    assert convolution(a[1:], b, subset=True, cycle=4) == \
+            [178104086592, 302255835516, 244982785880, 3717819845434]
+
+    assert convolution(a, b[:-1], subset=True, cycle=6) == [1932837114162,
+            178235365533, 213958794, 245166224504, 1413262436976, 2397553088697]
+
+    assert convolution(c, d, subset=True, cycle=3) == \
+            [p*u + p*x + q*w + r*v + r*y + s*u + t*w,
+             p*v + p*y + q*u + s*y + t*u + t*x,
+             p*w + q*y + r*u + t*v]
+
+    assert convolution(c, d, subset=True, cycle=5) == \
+            [p*u + q*y + t*v,
+             p*v + q*u + r*y + t*w,
+             p*w + r*u + s*y + t*x,
+             p*x + q*w + r*v + s*u,
+             p*y + t*u]
+
+    raises(ValueError, lambda: convolution([1, 2, 3], [4, 5, 6], cycle=-1))
+
+
+def test_convolution_fft():
+    assert all(convolution_fft([], x, dps=y) == [] for x in ([], [1]) for y in (None, 3))
+    assert convolution_fft([1, 2, 3], [4, 5, 6]) == [4, 13, 28, 27, 18]
+    assert convolution_fft([1], [5, 6, 7]) == [5, 6, 7]
+    assert convolution_fft([1, 3], [5, 6, 7]) == [5, 21, 25, 21]
+
+    assert convolution_fft([1 + 2*I], [2 + 3*I]) == [-4 + 7*I]
+    assert convolution_fft([1 + 2*I, 3 + 4*I, 5 + 3*I/5], [Rational(2, 5) + 4*I/7]) == \
+            [Rational(-26, 35) + I*48/35, Rational(-38, 35) + I*116/35, Rational(58, 35) + I*542/175]
+
+    assert convolution_fft([Rational(3, 4), Rational(5, 6)], [Rational(7, 8), Rational(1, 3), Rational(2, 5)]) == \
+                                    [Rational(21, 32), Rational(47, 48), Rational(26, 45), Rational(1, 3)]
+
+    assert convolution_fft([Rational(1, 9), Rational(2, 3), Rational(3, 5)], [Rational(2, 5), Rational(3, 7), Rational(4, 9)]) == \
+                                [Rational(2, 45), Rational(11, 35), Rational(8152, 14175), Rational(523, 945), Rational(4, 15)]
+
+    assert convolution_fft([pi, E, sqrt(2)], [sqrt(3), 1/pi, 1/E]) == \
+                    [sqrt(3)*pi, 1 + sqrt(3)*E, E/pi + pi*exp(-1) + sqrt(6),
+                                            sqrt(2)/pi + 1, sqrt(2)*exp(-1)]
+
+    assert convolution_fft([2321, 33123], [5321, 6321, 71323]) == \
+                        [12350041, 190918524, 374911166, 2362431729]
+
+    assert convolution_fft([312313, 31278232], [32139631, 319631]) == \
+                        [10037624576503, 1005370659728895, 9997492572392]
+
+    raises(TypeError, lambda: convolution_fft(x, y))
+    raises(ValueError, lambda: convolution_fft([x, y], [y, x]))
+
+
+def test_convolution_ntt():
+    # prime moduli of the form (m*2**k + 1), sequence length
+    # should be a divisor of 2**k
+    p = 7*17*2**23 + 1
+    q = 19*2**10 + 1
+    r = 2*500000003 + 1 # only for sequences of length 1 or 2
+    # s = 2*3*5*7 # composite modulus
+
+    assert all(convolution_ntt([], x, prime=y) == [] for x in ([], [1]) for y in (p, q, r))
+    assert convolution_ntt([2], [3], r) == [6]
+    assert convolution_ntt([2, 3], [4], r) == [8, 12]
+
+    assert convolution_ntt([32121, 42144, 4214, 4241], [32132, 3232, 87242], p) == [33867619,
+                                    459741727, 79180879, 831885249, 381344700, 369993322]
+    assert convolution_ntt([121913, 3171831, 31888131, 12], [17882, 21292, 29921, 312], q) == \
+                                                [8158, 3065, 3682, 7090, 1239, 2232, 3744]
+
+    assert convolution_ntt([12, 19, 21, 98, 67], [2, 6, 7, 8, 9], p) == \
+                    convolution_ntt([12, 19, 21, 98, 67], [2, 6, 7, 8, 9], q)
+    assert convolution_ntt([12, 19, 21, 98, 67], [21, 76, 17, 78, 69], p) == \
+                    convolution_ntt([12, 19, 21, 98, 67], [21, 76, 17, 78, 69], q)
+
+    raises(ValueError, lambda: convolution_ntt([2, 3], [4, 5], r))
+    raises(ValueError, lambda: convolution_ntt([x, y], [y, x], q))
+    raises(TypeError, lambda: convolution_ntt(x, y, p))
+
+
+def test_convolution_fwht():
+    assert convolution_fwht([], []) == []
+    assert convolution_fwht([], [1]) == []
+    assert convolution_fwht([1, 2, 3], [4, 5, 6]) == [32, 13, 18, 27]
+
+    assert convolution_fwht([Rational(5, 7), Rational(6, 8), Rational(7, 3)], [2, 4, Rational(6, 7)]) == \
+                                    [Rational(45, 7), Rational(61, 14), Rational(776, 147), Rational(419, 42)]
+
+    a = [1, Rational(5, 3), sqrt(3), Rational(7, 5), 4 + 5*I]
+    b = [94, 51, 53, 45, 31, 27, 13]
+    c = [3 + 4*I, 5 + 7*I, 3, Rational(7, 6), 8]
+
+    assert convolution_fwht(a, b) == [53*sqrt(3) + 366 + 155*I,
+                                    45*sqrt(3) + Rational(5848, 15) + 135*I,
+                                    94*sqrt(3) + Rational(1257, 5) + 65*I,
+                                    51*sqrt(3) + Rational(3974, 15),
+                                    13*sqrt(3) + 452 + 470*I,
+                                    Rational(4513, 15) + 255*I,
+                                    31*sqrt(3) + Rational(1314, 5) + 265*I,
+                                    27*sqrt(3) + Rational(3676, 15) + 225*I]
+
+    assert convolution_fwht(b, c) == [Rational(1993, 2) + 733*I, Rational(6215, 6) + 862*I,
+        Rational(1659, 2) + 527*I, Rational(1988, 3) + 551*I, 1019 + 313*I, Rational(3955, 6) + 325*I,
+        Rational(1175, 2) + 52*I, Rational(3253, 6) + 91*I]
+
+    assert convolution_fwht(a[3:], c) == [Rational(-54, 5) + I*293/5, -1 + I*204/5,
+            Rational(133, 15) + I*35/6, Rational(409, 30) + 15*I, Rational(56, 5), 32 + 40*I, 0, 0]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert convolution_fwht([u, v], [x, y]) == [u*x + v*y, u*y + v*x]
+
+    assert convolution_fwht([u, v, w], [x, y]) == \
+        [u*x + v*y, u*y + v*x, w*x, w*y]
+
+    assert convolution_fwht([u, v, w], [x, y, z]) == \
+        [u*x + v*y + w*z, u*y + v*x, u*z + w*x, v*z + w*y]
+
+    raises(TypeError, lambda: convolution_fwht(x, y))
+    raises(TypeError, lambda: convolution_fwht(x*y, u + v))
+
+
+def test_convolution_subset():
+    assert convolution_subset([], []) == []
+    assert convolution_subset([], [Rational(1, 3)]) == []
+    assert convolution_subset([6 + I*3/7], [Rational(2, 3)]) == [4 + I*2/7]
+
+    a = [1, Rational(5, 3), sqrt(3), 4 + 5*I]
+    b = [64, 71, 55, 47, 33, 29, 15]
+    c = [3 + I*2/3, 5 + 7*I, 7, Rational(7, 5), 9]
+
+    assert convolution_subset(a, b) == [64, Rational(533, 3), 55 + 64*sqrt(3),
+                                        71*sqrt(3) + Rational(1184, 3) + 320*I, 33, 84,
+                                        15 + 33*sqrt(3), 29*sqrt(3) + 157 + 165*I]
+
+    assert convolution_subset(b, c) == [192 + I*128/3, 533 + I*1486/3,
+                                        613 + I*110/3, Rational(5013, 5) + I*1249/3,
+                                        675 + 22*I, 891 + I*751/3,
+                                        771 + 10*I, Rational(3736, 5) + 105*I]
+
+    assert convolution_subset(a, c) == convolution_subset(c, a)
+    assert convolution_subset(a[:2], b) == \
+            [64, Rational(533, 3), 55, Rational(416, 3), 33, 84, 15, 25]
+
+    assert convolution_subset(a[:2], c) == \
+            [3 + I*2/3, 10 + I*73/9, 7, Rational(196, 15), 9, 15, 0, 0]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert convolution_subset([u, v, w], [x, y]) == [u*x, u*y + v*x, w*x, w*y]
+    assert convolution_subset([u, v, w, x], [y, z]) == \
+                            [u*y, u*z + v*y, w*y, w*z + x*y]
+
+    assert convolution_subset([u, v], [x, y, z]) == \
+                    convolution_subset([x, y, z], [u, v])
+
+    raises(TypeError, lambda: convolution_subset(x, z))
+    raises(TypeError, lambda: convolution_subset(Rational(7, 3), u))
+
+
+def test_covering_product():
+    assert covering_product([], []) == []
+    assert covering_product([], [Rational(1, 3)]) == []
+    assert covering_product([6 + I*3/7], [Rational(2, 3)]) == [4 + I*2/7]
+
+    a = [1, Rational(5, 8), sqrt(7), 4 + 9*I]
+    b = [66, 81, 95, 49, 37, 89, 17]
+    c = [3 + I*2/3, 51 + 72*I, 7, Rational(7, 15), 91]
+
+    assert covering_product(a, b) == [66, Rational(1383, 8), 95 + 161*sqrt(7),
+                                        130*sqrt(7) + 1303 + 2619*I, 37,
+                                        Rational(671, 4), 17 + 54*sqrt(7),
+                                        89*sqrt(7) + Rational(4661, 8) + 1287*I]
+
+    assert covering_product(b, c) == [198 + 44*I, 7740 + 10638*I,
+                                        1412 + I*190/3, Rational(42684, 5) + I*31202/3,
+                                        9484 + I*74/3, 22163 + I*27394/3,
+                                        10621 + I*34/3, Rational(90236, 15) + 1224*I]
+
+    assert covering_product(a, c) == covering_product(c, a)
+    assert covering_product(b, c[:-1]) == [198 + 44*I, 7740 + 10638*I,
+                                         1412 + I*190/3, Rational(42684, 5) + I*31202/3,
+                                         111 + I*74/3, 6693 + I*27394/3,
+                                         429 + I*34/3, Rational(23351, 15) + 1224*I]
+
+    assert covering_product(a, c[:-1]) == [3 + I*2/3,
+                            Rational(339, 4) + I*1409/12, 7 + 10*sqrt(7) + 2*sqrt(7)*I/3,
+                            -403 + 772*sqrt(7)/15 + 72*sqrt(7)*I + I*12658/15]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert covering_product([u, v, w], [x, y]) == \
+                            [u*x, u*y + v*x + v*y, w*x, w*y]
+
+    assert covering_product([u, v, w, x], [y, z]) == \
+                            [u*y, u*z + v*y + v*z, w*y, w*z + x*y + x*z]
+
+    assert covering_product([u, v], [x, y, z]) == \
+                    covering_product([x, y, z], [u, v])
+
+    raises(TypeError, lambda: covering_product(x, z))
+    raises(TypeError, lambda: covering_product(Rational(7, 3), u))
+
+
+def test_intersecting_product():
+    assert intersecting_product([], []) == []
+    assert intersecting_product([], [Rational(1, 3)]) == []
+    assert intersecting_product([6 + I*3/7], [Rational(2, 3)]) == [4 + I*2/7]
+
+    a = [1, sqrt(5), Rational(3, 8) + 5*I, 4 + 7*I]
+    b = [67, 51, 65, 48, 36, 79, 27]
+    c = [3 + I*2/5, 5 + 9*I, 7, Rational(7, 19), 13]
+
+    assert intersecting_product(a, b) == [195*sqrt(5) + Rational(6979, 8) + 1886*I,
+                                178*sqrt(5) + 520 + 910*I, Rational(841, 2) + 1344*I,
+                                192 + 336*I, 0, 0, 0, 0]
+
+    assert intersecting_product(b, c) == [Rational(128553, 19) + I*9521/5,
+                Rational(17820, 19) + 1602*I, Rational(19264, 19), Rational(336, 19), 1846, 0, 0, 0]
+
+    assert intersecting_product(a, c) == intersecting_product(c, a)
+    assert intersecting_product(b[1:], c[:-1]) == [Rational(64788, 19) + I*8622/5,
+                    Rational(12804, 19) + 1152*I, Rational(11508, 19), Rational(252, 19), 0, 0, 0, 0]
+
+    assert intersecting_product(a, c[:-2]) == \
+                    [Rational(-99, 5) + 10*sqrt(5) + 2*sqrt(5)*I/5 + I*3021/40,
+                    -43 + 5*sqrt(5) + 9*sqrt(5)*I + 71*I, Rational(245, 8) + 84*I, 0]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert intersecting_product([u, v, w], [x, y]) == \
+                            [u*x + u*y + v*x + w*x + w*y, v*y, 0, 0]
+
+    assert intersecting_product([u, v, w, x], [y, z]) == \
+                        [u*y + u*z + v*y + w*y + w*z + x*y, v*z + x*z, 0, 0]
+
+    assert intersecting_product([u, v], [x, y, z]) == \
+                    intersecting_product([x, y, z], [u, v])
+
+    raises(TypeError, lambda: intersecting_product(x, z))
+    raises(TypeError, lambda: intersecting_product(u, Rational(8, 3)))
+
+
+def test_convolution_int():
+    assert convolution_int([1], [1]) == [1]
+    assert convolution_int([1, 1], [0]) == [0]
+    assert convolution_int([1, 2, 3], [4, 5, 6]) == [4, 13, 28, 27, 18]
+    assert convolution_int([1], [5, 6, 7]) == [5, 6, 7]
+    assert convolution_int([1, 3], [5, 6, 7]) == [5, 21, 25, 21]
+    assert convolution_int([10, -5, 1, 3], [-5, 6, 7]) == [-50, 85, 35, -44, 25, 21]
+    assert convolution_int([0, 1, 0, -1], [1, 0, -1, 0]) == [0, 1, 0, -2, 0, 1]
+    assert convolution_int(
+        [-341, -5, 1, 3, -71, -99, 43, 87],
+        [5, 6, 7, 12, 345, 21, -78, -7, -89]
+    ) == [-1705, -2071, -2412, -4106, -118035, -9774, 25998, 2981, 5509,
+          -34317, 19228, 38870, 5485, 1724, -4436, -7743]

parrot/lib/python3.10/site-packages/sympy/discrete/tests/test_recurrences.py

@@ -0,0 +1,59 @@
+from sympy.core.numbers import Rational
+from sympy.functions.combinatorial.numbers import fibonacci
+from sympy.core import S, symbols
+from sympy.testing.pytest import raises
+from sympy.discrete.recurrences import linrec
+
+def test_linrec():
+    assert linrec(coeffs=[1, 1], init=[1, 1], n=20) == 10946
+    assert linrec(coeffs=[1, 2, 3, 4, 5], init=[1, 1, 0, 2], n=10) == 1040
+    assert linrec(coeffs=[0, 0, 11, 13], init=[23, 27], n=25) == 59628567384
+    assert linrec(coeffs=[0, 0, 1, 1, 2], init=[1, 5, 3], n=15) == 165
+    assert linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4], n=70) == \
+        56889923441670659718376223533331214868804815612050381493741233489928913241
+    assert linrec(coeffs=[0]*55 + [1, 1, 2, 3], init=[0]*50 + [1, 2, 3], n=4000) == \
+        702633573874937994980598979769135096432444135301118916539
+
+    assert linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4], n=10**4)
+    assert linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4], n=10**5)
+
+    assert all(linrec(coeffs=[1, 1], init=[0, 1], n=n) == fibonacci(n)
+                                                    for n in range(95, 115))
+
+    assert all(linrec(coeffs=[1, 1], init=[1, 1], n=n) == fibonacci(n + 1)
+                                                    for n in range(595, 615))
+
+    a = [S.Half, Rational(3, 4), Rational(5, 6), 7, Rational(8, 9), Rational(3, 5)]
+    b = [1, 2, 8, Rational(5, 7), Rational(3, 7), Rational(2, 9), 6]
+    x, y, z = symbols('x y z')
+
+    assert linrec(coeffs=a[:5], init=b[:4], n=80) == \
+        Rational(1726244235456268979436592226626304376013002142588105090705187189,
+            1960143456748895967474334873705475211264)
+
+    assert linrec(coeffs=a[:4], init=b[:4], n=50) == \
+        Rational(368949940033050147080268092104304441, 504857282956046106624)
+
+    assert linrec(coeffs=a[3:], init=b[:3], n=35) == \
+        Rational(97409272177295731943657945116791049305244422833125109,
+            814315512679031689453125)
+
+    assert linrec(coeffs=[0]*60 + [Rational(2, 3), Rational(4, 5)], init=b, n=3000) == \
+        Rational(26777668739896791448594650497024, 48084516708184142230517578125)
+
+    raises(TypeError, lambda: linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4, 5], n=1))
+    raises(TypeError, lambda: linrec(coeffs=a[:4], init=b[:5], n=10000))
+    raises(ValueError, lambda: linrec(coeffs=a[:4], init=b[:4], n=-10000))
+    raises(TypeError, lambda: linrec(x, b, n=10000))
+    raises(TypeError, lambda: linrec(a, y, n=10000))
+
+    assert linrec(coeffs=[x, y, z], init=[1, 1, 1], n=4) == \
+        x**2  + x*y + x*z + y + z
+    assert linrec(coeffs=[1, 2, 1], init=[x, y, z], n=20) == \
+        269542*x + 664575*y + 578949*z
+    assert linrec(coeffs=[0, 3, 1, 2], init=[x, y], n=30) == \
+        58516436*x + 56372788*y
+    assert linrec(coeffs=[0]*50 + [1, 2, 3], init=[x, y, z], n=1000) == \
+        11477135884896*x + 25999077948732*y + 41975630244216*z
+    assert linrec(coeffs=[], init=[1, 1], n=20) == 0
+    assert linrec(coeffs=[x, y, z], init=[1, 2, 3], n=2) == 3

parrot/lib/python3.10/site-packages/sympy/discrete/tests/test_transforms.py

@@ -0,0 +1,154 @@
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core import S, Symbol, symbols, I, Rational
+from sympy.discrete import (fft, ifft, ntt, intt, fwht, ifwht,
+    mobius_transform, inverse_mobius_transform)
+from sympy.testing.pytest import raises
+
+
+def test_fft_ifft():
+    assert all(tf(ls) == ls for tf in (fft, ifft)
+                            for ls in ([], [Rational(5, 3)]))
+
+    ls = list(range(6))
+    fls = [15, -7*sqrt(2)/2 - 4 - sqrt(2)*I/2 + 2*I, 2 + 3*I,
+             -4 + 7*sqrt(2)/2 - 2*I - sqrt(2)*I/2, -3,
+             -4 + 7*sqrt(2)/2 + sqrt(2)*I/2 + 2*I,
+              2 - 3*I, -7*sqrt(2)/2 - 4 - 2*I + sqrt(2)*I/2]
+
+    assert fft(ls) == fls
+    assert ifft(fls) == ls + [S.Zero]*2
+
+    ls = [1 + 2*I, 3 + 4*I, 5 + 6*I]
+    ifls = [Rational(9, 4) + 3*I, I*Rational(-7, 4), Rational(3, 4) + I, -2 - I/4]
+
+    assert ifft(ls) == ifls
+    assert fft(ifls) == ls + [S.Zero]
+
+    x = Symbol('x', real=True)
+    raises(TypeError, lambda: fft(x))
+    raises(ValueError, lambda: ifft([x, 2*x, 3*x**2, 4*x**3]))
+
+
+def test_ntt_intt():
+    # prime moduli of the form (m*2**k + 1), sequence length
+    # should be a divisor of 2**k
+    p = 7*17*2**23 + 1
+    q = 2*500000003 + 1 # only for sequences of length 1 or 2
+    r = 2*3*5*7 # composite modulus
+
+    assert all(tf(ls, p) == ls for tf in (ntt, intt)
+                                for ls in ([], [5]))
+
+    ls = list(range(6))
+    nls = [15, 801133602, 738493201, 334102277, 998244350, 849020224,
+            259751156, 12232587]
+
+    assert ntt(ls, p) == nls
+    assert intt(nls, p) == ls + [0]*2
+
+    ls = [1 + 2*I, 3 + 4*I, 5 + 6*I]
+    x = Symbol('x', integer=True)
+
+    raises(TypeError, lambda: ntt(x, p))
+    raises(ValueError, lambda: intt([x, 2*x, 3*x**2, 4*x**3], p))
+    raises(ValueError, lambda: intt(ls, p))
+    raises(ValueError, lambda: ntt([1.2, 2.1, 3.5], p))
+    raises(ValueError, lambda: ntt([3, 5, 6], q))
+    raises(ValueError, lambda: ntt([4, 5, 7], r))
+    raises(ValueError, lambda: ntt([1.0, 2.0, 3.0], p))
+
+
+def test_fwht_ifwht():
+    assert all(tf(ls) == ls for tf in (fwht, ifwht) \
+                        for ls in ([], [Rational(7, 4)]))
+
+    ls = [213, 321, 43235, 5325, 312, 53]
+    fls = [49459, 38061, -47661, -37759, 48729, 37543, -48391, -38277]
+
+    assert fwht(ls) == fls
+    assert ifwht(fls) == ls + [S.Zero]*2
+
+    ls = [S.Half + 2*I, Rational(3, 7) + 4*I, Rational(5, 6) + 6*I, Rational(7, 3), Rational(9, 4)]
+    ifls = [Rational(533, 672) + I*3/2, Rational(23, 224) + I/2, Rational(1, 672), Rational(107, 224) - I,
+        Rational(155, 672) + I*3/2, Rational(-103, 224) + I/2, Rational(-377, 672), Rational(-19, 224) - I]
+
+    assert ifwht(ls) == ifls
+    assert fwht(ifls) == ls + [S.Zero]*3
+
+    x, y = symbols('x y')
+
+    raises(TypeError, lambda: fwht(x))
+
+    ls = [x, 2*x, 3*x**2, 4*x**3]
+    ifls = [x**3 + 3*x**2/4 + x*Rational(3, 4),
+        -x**3 + 3*x**2/4 - x/4,
+        -x**3 - 3*x**2/4 + x*Rational(3, 4),
+        x**3 - 3*x**2/4 - x/4]
+
+    assert ifwht(ls) == ifls
+    assert fwht(ifls) == ls
+
+    ls = [x, y, x**2, y**2, x*y]
+    fls = [x**2 + x*y + x + y**2 + y,
+        x**2 + x*y + x - y**2 - y,
+        -x**2 + x*y + x - y**2 + y,
+        -x**2 + x*y + x + y**2 - y,
+        x**2 - x*y + x + y**2 + y,
+        x**2 - x*y + x - y**2 - y,
+        -x**2 - x*y + x - y**2 + y,
+        -x**2 - x*y + x + y**2 - y]
+
+    assert fwht(ls) == fls
+    assert ifwht(fls) == ls + [S.Zero]*3
+
+    ls = list(range(6))
+
+    assert fwht(ls) == [x*8 for x in ifwht(ls)]
+
+
+def test_mobius_transform():
+    assert all(tf(ls, subset=subset) == ls
+                for ls in ([], [Rational(7, 4)]) for subset in (True, False)
+                for tf in (mobius_transform, inverse_mobius_transform))
+
+    w, x, y, z = symbols('w x y z')
+
+    assert mobius_transform([x, y]) == [x, x + y]
+    assert inverse_mobius_transform([x, x + y]) == [x, y]
+    assert mobius_transform([x, y], subset=False) == [x + y, y]
+    assert inverse_mobius_transform([x + y, y], subset=False) == [x, y]
+
+    assert mobius_transform([w, x, y, z]) == [w, w + x, w + y, w + x + y + z]
+    assert inverse_mobius_transform([w, w + x, w + y, w + x + y + z]) == \
+            [w, x, y, z]
+    assert mobius_transform([w, x, y, z], subset=False) == \
+            [w + x + y + z, x + z, y + z, z]
+    assert inverse_mobius_transform([w + x + y + z, x + z, y + z, z], subset=False) == \
+            [w, x, y, z]
+
+    ls = [Rational(2, 3), Rational(6, 7), Rational(5, 8), 9, Rational(5, 3) + 7*I]
+    mls = [Rational(2, 3), Rational(32, 21), Rational(31, 24), Rational(1873, 168),
+            Rational(7, 3) + 7*I, Rational(67, 21) + 7*I, Rational(71, 24) + 7*I,
+            Rational(2153, 168) + 7*I]
+
+    assert mobius_transform(ls) == mls
+    assert inverse_mobius_transform(mls) == ls + [S.Zero]*3
+
+    mls = [Rational(2153, 168) + 7*I, Rational(69, 7), Rational(77, 8), 9, Rational(5, 3) + 7*I, 0, 0, 0]
+
+    assert mobius_transform(ls, subset=False) == mls
+    assert inverse_mobius_transform(mls, subset=False) == ls + [S.Zero]*3
+
+    ls = ls[:-1]
+    mls = [Rational(2, 3), Rational(32, 21), Rational(31, 24), Rational(1873, 168)]
+
+    assert mobius_transform(ls) == mls
+    assert inverse_mobius_transform(mls) == ls
+
+    mls = [Rational(1873, 168), Rational(69, 7), Rational(77, 8), 9]
+
+    assert mobius_transform(ls, subset=False) == mls
+    assert inverse_mobius_transform(mls, subset=False) == ls
+
+    raises(TypeError, lambda: mobius_transform(x, subset=True))
+    raises(TypeError, lambda: inverse_mobius_transform(y, subset=False))

parrot/lib/python3.10/site-packages/sympy/discrete/transforms.py

@@ -0,0 +1,425 @@
+"""
+Discrete Fourier Transform, Number Theoretic Transform,
+Walsh Hadamard Transform, Mobius Transform
+"""
+
+from sympy.core import S, Symbol, sympify
+from sympy.core.function import expand_mul
+from sympy.core.numbers import pi, I
+from sympy.functions.elementary.trigonometric import sin, cos
+from sympy.ntheory import isprime, primitive_root
+from sympy.utilities.iterables import ibin, iterable
+from sympy.utilities.misc import as_int
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                         Discrete Fourier Transform                         #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _fourier_transform(seq, dps, inverse=False):
+    """Utility function for the Discrete Fourier Transform"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of numeric coefficients "
+                        "for Fourier Transform")
+
+    a = [sympify(arg) for arg in seq]
+    if any(x.has(Symbol) for x in a):
+        raise ValueError("Expected non-symbolic coefficients")
+
+    n = len(a)
+    if n < 2:
+        return a
+
+    b = n.bit_length() - 1
+    if n&(n - 1): # not a power of 2
+        b += 1
+        n = 2**b
+
+    a += [S.Zero]*(n - len(a))
+    for i in range(1, n):
+        j = int(ibin(i, b, str=True)[::-1], 2)
+        if i < j:
+            a[i], a[j] = a[j], a[i]
+
+    ang = -2*pi/n if inverse else 2*pi/n
+
+    if dps is not None:
+        ang = ang.evalf(dps + 2)
+
+    w = [cos(ang*i) + I*sin(ang*i) for i in range(n // 2)]
+
+    h = 2
+    while h <= n:
+        hf, ut = h // 2, n // h
+        for i in range(0, n, h):
+            for j in range(hf):
+                u, v = a[i + j], expand_mul(a[i + j + hf]*w[ut * j])
+                a[i + j], a[i + j + hf] = u + v, u - v
+        h *= 2
+
+    if inverse:
+        a = [(x/n).evalf(dps) for x in a] if dps is not None \
+                            else [x/n for x in a]
+
+    return a
+
+
+def fft(seq, dps=None):
+    r"""
+    Performs the Discrete Fourier Transform (**DFT**) in the complex domain.
+
+    The sequence is automatically padded to the right with zeros, as the
+    *radix-2 FFT* requires the number of sample points to be a power of 2.
+
+    This method should be used with default arguments only for short sequences
+    as the complexity of expressions increases with the size of the sequence.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which **DFT** is to be applied.
+    dps : Integer
+        Specifies the number of decimal digits for precision.
+
+    Examples
+    ========
+
+    >>> from sympy import fft, ifft
+
+    >>> fft([1, 2, 3, 4])
+    [10, -2 - 2*I, -2, -2 + 2*I]
+    >>> ifft(_)
+    [1, 2, 3, 4]
+
+    >>> ifft([1, 2, 3, 4])
+    [5/2, -1/2 + I/2, -1/2, -1/2 - I/2]
+    >>> fft(_)
+    [1, 2, 3, 4]
+
+    >>> ifft([1, 7, 3, 4], dps=15)
+    [3.75, -0.5 - 0.75*I, -1.75, -0.5 + 0.75*I]
+    >>> fft(_)
+    [1.0, 7.0, 3.0, 4.0]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm
+    .. [2] https://mathworld.wolfram.com/FastFourierTransform.html
+
+    """
+
+    return _fourier_transform(seq, dps=dps)
+
+
+def ifft(seq, dps=None):
+    return _fourier_transform(seq, dps=dps, inverse=True)
+
+ifft.__doc__ = fft.__doc__
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                         Number Theoretic Transform                         #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _number_theoretic_transform(seq, prime, inverse=False):
+    """Utility function for the Number Theoretic Transform"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of integer coefficients "
+                        "for Number Theoretic Transform")
+
+    p = as_int(prime)
+    if not isprime(p):
+        raise ValueError("Expected prime modulus for "
+                        "Number Theoretic Transform")
+
+    a = [as_int(x) % p for x in seq]
+
+    n = len(a)
+    if n < 1:
+        return a
+
+    b = n.bit_length() - 1
+    if n&(n - 1):
+        b += 1
+        n = 2**b
+
+    if (p - 1) % n:
+        raise ValueError("Expected prime modulus of the form (m*2**k + 1)")
+
+    a += [0]*(n - len(a))
+    for i in range(1, n):
+        j = int(ibin(i, b, str=True)[::-1], 2)
+        if i < j:
+            a[i], a[j] = a[j], a[i]
+
+    pr = primitive_root(p)
+
+    rt = pow(pr, (p - 1) // n, p)
+    if inverse:
+        rt = pow(rt, p - 2, p)
+
+    w = [1]*(n // 2)
+    for i in range(1, n // 2):
+        w[i] = w[i - 1]*rt % p
+
+    h = 2
+    while h <= n:
+        hf, ut = h // 2, n // h
+        for i in range(0, n, h):
+            for j in range(hf):
+                u, v = a[i + j], a[i + j + hf]*w[ut * j]
+                a[i + j], a[i + j + hf] = (u + v) % p, (u - v) % p
+        h *= 2
+
+    if inverse:
+        rv = pow(n, p - 2, p)
+        a = [x*rv % p for x in a]
+
+    return a
+
+
+def ntt(seq, prime):
+    r"""
+    Performs the Number Theoretic Transform (**NTT**), which specializes the
+    Discrete Fourier Transform (**DFT**) over quotient ring `Z/pZ` for prime
+    `p` instead of complex numbers `C`.
+
+    The sequence is automatically padded to the right with zeros, as the
+    *radix-2 NTT* requires the number of sample points to be a power of 2.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which **DFT** is to be applied.
+    prime : Integer
+        Prime modulus of the form `(m 2^k + 1)` to be used for performing
+        **NTT** on the sequence.
+
+    Examples
+    ========
+
+    >>> from sympy import ntt, intt
+    >>> ntt([1, 2, 3, 4], prime=3*2**8 + 1)
+    [10, 643, 767, 122]
+    >>> intt(_, 3*2**8 + 1)
+    [1, 2, 3, 4]
+    >>> intt([1, 2, 3, 4], prime=3*2**8 + 1)
+    [387, 415, 384, 353]
+    >>> ntt(_, prime=3*2**8 + 1)
+    [1, 2, 3, 4]
+
+    References
+    ==========
+
+    .. [1] http://www.apfloat.org/ntt.html
+    .. [2] https://mathworld.wolfram.com/NumberTheoreticTransform.html
+    .. [3] https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general%29
+
+    """
+
+    return _number_theoretic_transform(seq, prime=prime)
+
+
+def intt(seq, prime):
+    return _number_theoretic_transform(seq, prime=prime, inverse=True)
+
+intt.__doc__ = ntt.__doc__
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                          Walsh Hadamard Transform                          #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _walsh_hadamard_transform(seq, inverse=False):
+    """Utility function for the Walsh Hadamard Transform"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of coefficients "
+                        "for Walsh Hadamard Transform")
+
+    a = [sympify(arg) for arg in seq]
+    n = len(a)
+    if n < 2:
+        return a
+
+    if n&(n - 1):
+        n = 2**n.bit_length()
+
+    a += [S.Zero]*(n - len(a))
+    h = 2
+    while h <= n:
+        hf = h // 2
+        for i in range(0, n, h):
+            for j in range(hf):
+                u, v = a[i + j], a[i + j + hf]
+                a[i + j], a[i + j + hf] = u + v, u - v
+        h *= 2
+
+    if inverse:
+        a = [x/n for x in a]
+
+    return a
+
+
+def fwht(seq):
+    r"""
+    Performs the Walsh Hadamard Transform (**WHT**), and uses Hadamard
+    ordering for the sequence.
+
+    The sequence is automatically padded to the right with zeros, as the
+    *radix-2 FWHT* requires the number of sample points to be a power of 2.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which WHT is to be applied.
+
+    Examples
+    ========
+
+    >>> from sympy import fwht, ifwht
+    >>> fwht([4, 2, 2, 0, 0, 2, -2, 0])
+    [8, 0, 8, 0, 8, 8, 0, 0]
+    >>> ifwht(_)
+    [4, 2, 2, 0, 0, 2, -2, 0]
+
+    >>> ifwht([19, -1, 11, -9, -7, 13, -15, 5])
+    [2, 0, 4, 0, 3, 10, 0, 0]
+    >>> fwht(_)
+    [19, -1, 11, -9, -7, 13, -15, 5]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hadamard_transform
+    .. [2] https://en.wikipedia.org/wiki/Fast_Walsh%E2%80%93Hadamard_transform
+
+    """
+
+    return _walsh_hadamard_transform(seq)
+
+
+def ifwht(seq):
+    return _walsh_hadamard_transform(seq, inverse=True)
+
+ifwht.__doc__ = fwht.__doc__
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                    Mobius Transform for Subset Lattice                     #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _mobius_transform(seq, sgn, subset):
+    r"""Utility function for performing Mobius Transform using
+    Yate's Dynamic Programming method"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of coefficients")
+
+    a = [sympify(arg) for arg in seq]
+
+    n = len(a)
+    if n < 2:
+        return a
+
+    if n&(n - 1):
+        n = 2**n.bit_length()
+
+    a += [S.Zero]*(n - len(a))
+
+    if subset:
+        i = 1
+        while i < n:
+            for j in range(n):
+                if j & i:
+                    a[j] += sgn*a[j ^ i]
+            i *= 2
+
+    else:
+        i = 1
+        while i < n:
+            for j in range(n):
+                if j & i:
+                    continue
+                a[j] += sgn*a[j ^ i]
+            i *= 2
+
+    return a
+
+
+def mobius_transform(seq, subset=True):
+    r"""
+    Performs the Mobius Transform for subset lattice with indices of
+    sequence as bitmasks.
+
+    The indices of each argument, considered as bit strings, correspond
+    to subsets of a finite set.
+
+    The sequence is automatically padded to the right with zeros, as the
+    definition of subset/superset based on bitmasks (indices) requires
+    the size of sequence to be a power of 2.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which Mobius Transform is to be applied.
+    subset : bool
+        Specifies if Mobius Transform is applied by enumerating subsets
+        or supersets of the given set.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols
+    >>> from sympy import mobius_transform, inverse_mobius_transform
+    >>> x, y, z = symbols('x y z')
+
+    >>> mobius_transform([x, y, z])
+    [x, x + y, x + z, x + y + z]
+    >>> inverse_mobius_transform(_)
+    [x, y, z, 0]
+
+    >>> mobius_transform([x, y, z], subset=False)
+    [x + y + z, y, z, 0]
+    >>> inverse_mobius_transform(_, subset=False)
+    [x, y, z, 0]
+
+    >>> mobius_transform([1, 2, 3, 4])
+    [1, 3, 4, 10]
+    >>> inverse_mobius_transform(_)
+    [1, 2, 3, 4]
+    >>> mobius_transform([1, 2, 3, 4], subset=False)
+    [10, 6, 7, 4]
+    >>> inverse_mobius_transform(_, subset=False)
+    [1, 2, 3, 4]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/M%C3%B6bius_inversion_formula
+    .. [2] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf
+    .. [3] https://arxiv.org/pdf/1211.0189.pdf
+
+    """
+
+    return _mobius_transform(seq, sgn=+1, subset=subset)
+
+def inverse_mobius_transform(seq, subset=True):
+    return _mobius_transform(seq, sgn=-1, subset=subset)
+
+inverse_mobius_transform.__doc__ = mobius_transform.__doc__

parrot/lib/python3.10/site-packages/sympy/multipledispatch/__init__.py

@@ -0,0 +1,11 @@
+from .core import dispatch
+from .dispatcher import (Dispatcher, halt_ordering, restart_ordering,
+    MDNotImplementedError)
+
+__version__ = '0.4.9'
+
+__all__ = [
+    'dispatch',
+
+    'Dispatcher', 'halt_ordering', 'restart_ordering', 'MDNotImplementedError',
+]

parrot/lib/python3.10/site-packages/sympy/multipledispatch/conflict.py

@@ -0,0 +1,68 @@
+from .utils import _toposort, groupby
+
+class AmbiguityWarning(Warning):
+    pass
+
+
+def supercedes(a, b):
+    """ A is consistent and strictly more specific than B """
+    return len(a) == len(b) and all(map(issubclass, a, b))
+
+
+def consistent(a, b):
+    """ It is possible for an argument list to satisfy both A and B """
+    return (len(a) == len(b) and
+            all(issubclass(aa, bb) or issubclass(bb, aa)
+                           for aa, bb in zip(a, b)))
+
+
+def ambiguous(a, b):
+    """ A is consistent with B but neither is strictly more specific """
+    return consistent(a, b) and not (supercedes(a, b) or supercedes(b, a))
+
+
+def ambiguities(signatures):
+    """ All signature pairs such that A is ambiguous with B """
+    signatures = list(map(tuple, signatures))
+    return {(a, b) for a in signatures for b in signatures
+                       if hash(a) < hash(b)
+                       and ambiguous(a, b)
+                       and not any(supercedes(c, a) and supercedes(c, b)
+                                    for c in signatures)}
+
+
+def super_signature(signatures):
+    """ A signature that would break ambiguities """
+    n = len(signatures[0])
+    assert all(len(s) == n for s in signatures)
+
+    return [max([type.mro(sig[i]) for sig in signatures], key=len)[0]
+               for i in range(n)]
+
+
+def edge(a, b, tie_breaker=hash):
+    """ A should be checked before B
+
+    Tie broken by tie_breaker, defaults to ``hash``
+    """
+    if supercedes(a, b):
+        if supercedes(b, a):
+            return tie_breaker(a) > tie_breaker(b)
+        else:
+            return True
+    return False
+
+
+def ordering(signatures):
+    """ A sane ordering of signatures to check, first to last
+
+    Topoological sort of edges as given by ``edge`` and ``supercedes``
+    """
+    signatures = list(map(tuple, signatures))
+    edges = [(a, b) for a in signatures for b in signatures if edge(a, b)]
+    edges = groupby(lambda x: x[0], edges)
+    for s in signatures:
+        if s not in edges:
+            edges[s] = []
+    edges = {k: [b for a, b in v] for k, v in edges.items()}
+    return _toposort(edges)

parrot/lib/python3.10/site-packages/sympy/multipledispatch/core.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+from typing import Any
+
+import inspect
+
+from .dispatcher import Dispatcher, MethodDispatcher, ambiguity_warn
+
+# XXX: This parameter to dispatch isn't documented and isn't used anywhere in
+# sympy. Maybe it should just be removed.
+global_namespace: dict[str, Any] = {}
+
+
+def dispatch(*types, namespace=global_namespace, on_ambiguity=ambiguity_warn):
+    """ Dispatch function on the types of the inputs
+
+    Supports dispatch on all non-keyword arguments.
+
+    Collects implementations based on the function name.  Ignores namespaces.
+
+    If ambiguous type signatures occur a warning is raised when the function is
+    defined suggesting the additional method to break the ambiguity.
+
+    Examples
+    --------
+
+    >>> from sympy.multipledispatch import dispatch
+    >>> @dispatch(int)
+    ... def f(x):
+    ...     return x + 1
+
+    >>> @dispatch(float)
+    ... def f(x): # noqa: F811
+    ...     return x - 1
+
+    >>> f(3)
+    4
+    >>> f(3.0)
+    2.0
+
+    Specify an isolated namespace with the namespace keyword argument
+
+    >>> my_namespace = dict()
+    >>> @dispatch(int, namespace=my_namespace)
+    ... def foo(x):
+    ...     return x + 1
+
+    Dispatch on instance methods within classes
+
+    >>> class MyClass(object):
+    ...     @dispatch(list)
+    ...     def __init__(self, data):
+    ...         self.data = data
+    ...     @dispatch(int)
+    ...     def __init__(self, datum): # noqa: F811
+    ...         self.data = [datum]
+    """
+    types = tuple(types)
+
+    def _(func):
+        name = func.__name__
+
+        if ismethod(func):
+            dispatcher = inspect.currentframe().f_back.f_locals.get(
+                name,
+                MethodDispatcher(name))
+        else:
+            if name not in namespace:
+                namespace[name] = Dispatcher(name)
+            dispatcher = namespace[name]
+
+        dispatcher.add(types, func, on_ambiguity=on_ambiguity)
+        return dispatcher
+    return _
+
+
+def ismethod(func):
+    """ Is func a method?
+
+    Note that this has to work as the method is defined but before the class is
+    defined.  At this stage methods look like functions.
+    """
+    signature = inspect.signature(func)
+    return signature.parameters.get('self', None) is not None

parrot/lib/python3.10/site-packages/sympy/multipledispatch/dispatcher.py

@@ -0,0 +1,413 @@
+from __future__ import annotations
+
+from warnings import warn
+import inspect
+from .conflict import ordering, ambiguities, super_signature, AmbiguityWarning
+from .utils import expand_tuples
+import itertools as itl
+
+
+class MDNotImplementedError(NotImplementedError):
+    """ A NotImplementedError for multiple dispatch """
+
+
+### Functions for on_ambiguity
+
+def ambiguity_warn(dispatcher, ambiguities):
+    """ Raise warning when ambiguity is detected
+
+    Parameters
+    ----------
+    dispatcher : Dispatcher
+        The dispatcher on which the ambiguity was detected
+    ambiguities : set
+        Set of type signature pairs that are ambiguous within this dispatcher
+
+    See Also:
+        Dispatcher.add
+        warning_text
+    """
+    warn(warning_text(dispatcher.name, ambiguities), AmbiguityWarning)
+
+
+class RaiseNotImplementedError:
+    """Raise ``NotImplementedError`` when called."""
+
+    def __init__(self, dispatcher):
+        self.dispatcher = dispatcher
+
+    def __call__(self, *args, **kwargs):
+        types = tuple(type(a) for a in args)
+        raise NotImplementedError(
+            "Ambiguous signature for %s: <%s>" % (
+            self.dispatcher.name, str_signature(types)
+        ))
+
+def ambiguity_register_error_ignore_dup(dispatcher, ambiguities):
+    """
+    If super signature for ambiguous types is duplicate types, ignore it.
+    Else, register instance of ``RaiseNotImplementedError`` for ambiguous types.
+
+    Parameters
+    ----------
+    dispatcher : Dispatcher
+        The dispatcher on which the ambiguity was detected
+    ambiguities : set
+        Set of type signature pairs that are ambiguous within this dispatcher
+
+    See Also:
+        Dispatcher.add
+        ambiguity_warn
+    """
+    for amb in ambiguities:
+        signature = tuple(super_signature(amb))
+        if len(set(signature)) == 1:
+            continue
+        dispatcher.add(
+            signature, RaiseNotImplementedError(dispatcher),
+            on_ambiguity=ambiguity_register_error_ignore_dup
+        )
+
+###
+
+
+_unresolved_dispatchers: set[Dispatcher] = set()
+_resolve = [True]
+
+
+def halt_ordering():
+    _resolve[0] = False
+
+
+def restart_ordering(on_ambiguity=ambiguity_warn):
+    _resolve[0] = True
+    while _unresolved_dispatchers:
+        dispatcher = _unresolved_dispatchers.pop()
+        dispatcher.reorder(on_ambiguity=on_ambiguity)
+
+
+class Dispatcher:
+    """ Dispatch methods based on type signature
+
+    Use ``dispatch`` to add implementations
+
+    Examples
+    --------
+
+    >>> from sympy.multipledispatch import dispatch
+    >>> @dispatch(int)
+    ... def f(x):
+    ...     return x + 1
+
+    >>> @dispatch(float)
+    ... def f(x): # noqa: F811
+    ...     return x - 1
+
+    >>> f(3)
+    4
+    >>> f(3.0)
+    2.0
+    """
+    __slots__ = '__name__', 'name', 'funcs', 'ordering', '_cache', 'doc'
+
+    def __init__(self, name, doc=None):
+        self.name = self.__name__ = name
+        self.funcs = {}
+        self._cache = {}
+        self.ordering = []
+        self.doc = doc
+
+    def register(self, *types, **kwargs):
+        """ Register dispatcher with new implementation
+
+        >>> from sympy.multipledispatch.dispatcher import Dispatcher
+        >>> f = Dispatcher('f')
+        >>> @f.register(int)
+        ... def inc(x):
+        ...     return x + 1
+
+        >>> @f.register(float)
+        ... def dec(x):
+        ...     return x - 1
+
+        >>> @f.register(list)
+        ... @f.register(tuple)
+        ... def reverse(x):
+        ...     return x[::-1]
+
+        >>> f(1)
+        2
+
+        >>> f(1.0)
+        0.0
+
+        >>> f([1, 2, 3])
+        [3, 2, 1]
+        """
+        def _(func):
+            self.add(types, func, **kwargs)
+            return func
+        return _
+
+    @classmethod
+    def get_func_params(cls, func):
+        if hasattr(inspect, "signature"):
+            sig = inspect.signature(func)
+            return sig.parameters.values()
+
+    @classmethod
+    def get_func_annotations(cls, func):
+        """ Get annotations of function positional parameters
+        """
+        params = cls.get_func_params(func)
+        if params:
+            Parameter = inspect.Parameter
+
+            params = (param for param in params
+                      if param.kind in
+                      (Parameter.POSITIONAL_ONLY,
+                       Parameter.POSITIONAL_OR_KEYWORD))
+
+            annotations = tuple(
+                param.annotation
+                for param in params)
+
+            if not any(ann is Parameter.empty for ann in annotations):
+                return annotations
+
+    def add(self, signature, func, on_ambiguity=ambiguity_warn):
+        """ Add new types/method pair to dispatcher
+
+        >>> from sympy.multipledispatch import Dispatcher
+        >>> D = Dispatcher('add')
+        >>> D.add((int, int), lambda x, y: x + y)
+        >>> D.add((float, float), lambda x, y: x + y)
+
+        >>> D(1, 2)
+        3
+        >>> D(1, 2.0)
+        Traceback (most recent call last):
+        ...
+        NotImplementedError: Could not find signature for add: <int, float>
+
+        When ``add`` detects a warning it calls the ``on_ambiguity`` callback
+        with a dispatcher/itself, and a set of ambiguous type signature pairs
+        as inputs.  See ``ambiguity_warn`` for an example.
+        """
+        # Handle annotations
+        if not signature:
+            annotations = self.get_func_annotations(func)
+            if annotations:
+                signature = annotations
+
+        # Handle union types
+        if any(isinstance(typ, tuple) for typ in signature):
+            for typs in expand_tuples(signature):
+                self.add(typs, func, on_ambiguity)
+            return
+
+        for typ in signature:
+            if not isinstance(typ, type):
+                str_sig = ', '.join(c.__name__ if isinstance(c, type)
+                                    else str(c) for c in signature)
+                raise TypeError("Tried to dispatch on non-type: %s\n"
+                                "In signature: <%s>\n"
+                                "In function: %s" %
+                                (typ, str_sig, self.name))
+
+        self.funcs[signature] = func
+        self.reorder(on_ambiguity=on_ambiguity)
+        self._cache.clear()
+
+    def reorder(self, on_ambiguity=ambiguity_warn):
+        if _resolve[0]:
+            self.ordering = ordering(self.funcs)
+            amb = ambiguities(self.funcs)
+            if amb:
+                on_ambiguity(self, amb)
+        else:
+            _unresolved_dispatchers.add(self)
+
+    def __call__(self, *args, **kwargs):
+        types = tuple([type(arg) for arg in args])
+        try:
+            func = self._cache[types]
+        except KeyError:
+            func = self.dispatch(*types)
+            if not func:
+                raise NotImplementedError(
+                    'Could not find signature for %s: <%s>' %
+                    (self.name, str_signature(types)))
+            self._cache[types] = func
+        try:
+            return func(*args, **kwargs)
+
+        except MDNotImplementedError:
+            funcs = self.dispatch_iter(*types)
+            next(funcs)  # burn first
+            for func in funcs:
+                try:
+                    return func(*args, **kwargs)
+                except MDNotImplementedError:
+                    pass
+            raise NotImplementedError("Matching functions for "
+                                      "%s: <%s> found, but none completed successfully"
+                                      % (self.name, str_signature(types)))
+
+    def __str__(self):
+        return "<dispatched %s>" % self.name
+    __repr__ = __str__
+
+    def dispatch(self, *types):
+        """ Deterimine appropriate implementation for this type signature
+
+        This method is internal.  Users should call this object as a function.
+        Implementation resolution occurs within the ``__call__`` method.
+
+        >>> from sympy.multipledispatch import dispatch
+        >>> @dispatch(int)
+        ... def inc(x):
+        ...     return x + 1
+
+        >>> implementation = inc.dispatch(int)
+        >>> implementation(3)
+        4
+
+        >>> print(inc.dispatch(float))
+        None
+
+        See Also:
+            ``sympy.multipledispatch.conflict`` - module to determine resolution order
+        """
+
+        if types in self.funcs:
+            return self.funcs[types]
+
+        try:
+            return next(self.dispatch_iter(*types))
+        except StopIteration:
+            return None
+
+    def dispatch_iter(self, *types):
+        n = len(types)
+        for signature in self.ordering:
+            if len(signature) == n and all(map(issubclass, types, signature)):
+                result = self.funcs[signature]
+                yield result
+
+    def resolve(self, types):
+        """ Deterimine appropriate implementation for this type signature
+
+        .. deprecated:: 0.4.4
+            Use ``dispatch(*types)`` instead
+        """
+        warn("resolve() is deprecated, use dispatch(*types)",
+             DeprecationWarning)
+
+        return self.dispatch(*types)
+
+    def __getstate__(self):
+        return {'name': self.name,
+                'funcs': self.funcs}
+
+    def __setstate__(self, d):
+        self.name = d['name']
+        self.funcs = d['funcs']
+        self.ordering = ordering(self.funcs)
+        self._cache = {}
+
+    @property
+    def __doc__(self):
+        docs = ["Multiply dispatched method: %s" % self.name]
+
+        if self.doc:
+            docs.append(self.doc)
+
+        other = []
+        for sig in self.ordering[::-1]:
+            func = self.funcs[sig]
+            if func.__doc__:
+                s = 'Inputs: <%s>\n' % str_signature(sig)
+                s += '-' * len(s) + '\n'
+                s += func.__doc__.strip()
+                docs.append(s)
+            else:
+                other.append(str_signature(sig))
+
+        if other:
+            docs.append('Other signatures:\n    ' + '\n    '.join(other))
+
+        return '\n\n'.join(docs)
+
+    def _help(self, *args):
+        return self.dispatch(*map(type, args)).__doc__
+
+    def help(self, *args, **kwargs):
+        """ Print docstring for the function corresponding to inputs """
+        print(self._help(*args))
+
+    def _source(self, *args):
+        func = self.dispatch(*map(type, args))
+        if not func:
+            raise TypeError("No function found")
+        return source(func)
+
+    def source(self, *args, **kwargs):
+        """ Print source code for the function corresponding to inputs """
+        print(self._source(*args))
+
+
+def source(func):
+    s = 'File: %s\n\n' % inspect.getsourcefile(func)
+    s = s + inspect.getsource(func)
+    return s
+
+
+class MethodDispatcher(Dispatcher):
+    """ Dispatch methods based on type signature
+
+    See Also:
+        Dispatcher
+    """
+
+    @classmethod
+    def get_func_params(cls, func):
+        if hasattr(inspect, "signature"):
+            sig = inspect.signature(func)
+            return itl.islice(sig.parameters.values(), 1, None)
+
+    def __get__(self, instance, owner):
+        self.obj = instance
+        self.cls = owner
+        return self
+
+    def __call__(self, *args, **kwargs):
+        types = tuple([type(arg) for arg in args])
+        func = self.dispatch(*types)
+        if not func:
+            raise NotImplementedError('Could not find signature for %s: <%s>' %
+                                      (self.name, str_signature(types)))
+        return func(self.obj, *args, **kwargs)
+
+
+def str_signature(sig):
+    """ String representation of type signature
+
+    >>> from sympy.multipledispatch.dispatcher import str_signature
+    >>> str_signature((int, float))
+    'int, float'
+    """
+    return ', '.join(cls.__name__ for cls in sig)
+
+
+def warning_text(name, amb):
+    """ The text for ambiguity warnings """
+    text = "\nAmbiguities exist in dispatched function %s\n\n" % (name)
+    text += "The following signatures may result in ambiguous behavior:\n"
+    for pair in amb:
+        text += "\t" + \
+            ', '.join('[' + str_signature(s) + ']' for s in pair) + "\n"
+    text += "\n\nConsider making the following additions:\n\n"
+    text += '\n\n'.join(['@dispatch(' + str_signature(super_signature(s))
+                         + ')\ndef %s(...)' % name for s in amb])
+    return text

parrot/lib/python3.10/site-packages/sympy/multipledispatch/tests/test_dispatcher.py

@@ -0,0 +1,284 @@
+from sympy.multipledispatch.dispatcher import (Dispatcher, MDNotImplementedError,
+                                         MethodDispatcher, halt_ordering,
+                                         restart_ordering,
+                                         ambiguity_register_error_ignore_dup)
+from sympy.testing.pytest import raises, warns
+
+
+def identity(x):
+    return x
+
+
+def inc(x):
+    return x + 1
+
+
+def dec(x):
+    return x - 1
+
+
+def test_dispatcher():
+    f = Dispatcher('f')
+    f.add((int,), inc)
+    f.add((float,), dec)
+
+    with warns(DeprecationWarning, test_stacklevel=False):
+        assert f.resolve((int,)) == inc
+    assert f.dispatch(int) is inc
+
+    assert f(1) == 2
+    assert f(1.0) == 0.0
+
+
+def test_union_types():
+    f = Dispatcher('f')
+    f.register((int, float))(inc)
+
+    assert f(1) == 2
+    assert f(1.0) == 2.0
+
+
+def test_dispatcher_as_decorator():
+    f = Dispatcher('f')
+
+    @f.register(int)
+    def inc(x): # noqa:F811
+        return x + 1
+
+    @f.register(float) # noqa:F811
+    def inc(x): # noqa:F811
+        return x - 1
+
+    assert f(1) == 2
+    assert f(1.0) == 0.0
+
+
+def test_register_instance_method():
+
+    class Test:
+        __init__ = MethodDispatcher('f')
+
+        @__init__.register(list)
+        def _init_list(self, data):
+            self.data = data
+
+        @__init__.register(object)
+        def _init_obj(self, datum):
+            self.data = [datum]
+
+    a = Test(3)
+    b = Test([3])
+    assert a.data == b.data
+
+
+def test_on_ambiguity():
+    f = Dispatcher('f')
+
+    def identity(x): return x
+
+    ambiguities = [False]
+
+    def on_ambiguity(dispatcher, amb):
+        ambiguities[0] = True
+
+    f.add((object, object), identity, on_ambiguity=on_ambiguity)
+    assert not ambiguities[0]
+    f.add((object, float), identity, on_ambiguity=on_ambiguity)
+    assert not ambiguities[0]
+    f.add((float, object), identity, on_ambiguity=on_ambiguity)
+    assert ambiguities[0]
+
+
+def test_raise_error_on_non_class():
+    f = Dispatcher('f')
+    assert raises(TypeError, lambda: f.add((1,), inc))
+
+
+def test_docstring():
+
+    def one(x, y):
+        """ Docstring number one """
+        return x + y
+
+    def two(x, y):
+        """ Docstring number two """
+        return x + y
+
+    def three(x, y):
+        return x + y
+
+    master_doc = 'Doc of the multimethod itself'
+
+    f = Dispatcher('f', doc=master_doc)
+    f.add((object, object), one)
+    f.add((int, int), two)
+    f.add((float, float), three)
+
+    assert one.__doc__.strip() in f.__doc__
+    assert two.__doc__.strip() in f.__doc__
+    assert f.__doc__.find(one.__doc__.strip()) < \
+        f.__doc__.find(two.__doc__.strip())
+    assert 'object, object' in f.__doc__
+    assert master_doc in f.__doc__
+
+
+def test_help():
+    def one(x, y):
+        """ Docstring number one """
+        return x + y
+
+    def two(x, y):
+        """ Docstring number two """
+        return x + y
+
+    def three(x, y):
+        """ Docstring number three """
+        return x + y
+
+    master_doc = 'Doc of the multimethod itself'
+
+    f = Dispatcher('f', doc=master_doc)
+    f.add((object, object), one)
+    f.add((int, int), two)
+    f.add((float, float), three)
+
+    assert f._help(1, 1) == two.__doc__
+    assert f._help(1.0, 2.0) == three.__doc__
+
+
+def test_source():
+    def one(x, y):
+        """ Docstring number one """
+        return x + y
+
+    def two(x, y):
+        """ Docstring number two """
+        return x - y
+
+    master_doc = 'Doc of the multimethod itself'
+
+    f = Dispatcher('f', doc=master_doc)
+    f.add((int, int), one)
+    f.add((float, float), two)
+
+    assert 'x + y' in f._source(1, 1)
+    assert 'x - y' in f._source(1.0, 1.0)
+
+
+def test_source_raises_on_missing_function():
+    f = Dispatcher('f')
+
+    assert raises(TypeError, lambda: f.source(1))
+
+
+def test_halt_method_resolution():
+    g = [0]
+
+    def on_ambiguity(a, b):
+        g[0] += 1
+
+    f = Dispatcher('f')
+
+    halt_ordering()
+
+    def func(*args):
+        pass
+
+    f.add((int, object), func)
+    f.add((object, int), func)
+
+    assert g == [0]
+
+    restart_ordering(on_ambiguity=on_ambiguity)
+
+    assert g == [1]
+
+    assert set(f.ordering) == {(int, object), (object, int)}
+
+
+def test_no_implementations():
+    f = Dispatcher('f')
+    assert raises(NotImplementedError, lambda: f('hello'))
+
+
+def test_register_stacking():
+    f = Dispatcher('f')
+
+    @f.register(list)
+    @f.register(tuple)
+    def rev(x):
+        return x[::-1]
+
+    assert f((1, 2, 3)) == (3, 2, 1)
+    assert f([1, 2, 3]) == [3, 2, 1]
+
+    assert raises(NotImplementedError, lambda: f('hello'))
+    assert rev('hello') == 'olleh'
+
+
+def test_dispatch_method():
+    f = Dispatcher('f')
+
+    @f.register(list)
+    def rev(x):
+        return x[::-1]
+
+    @f.register(int, int)
+    def add(x, y):
+        return x + y
+
+    class MyList(list):
+        pass
+
+    assert f.dispatch(list) is rev
+    assert f.dispatch(MyList) is rev
+    assert f.dispatch(int, int) is add
+
+
+def test_not_implemented():
+    f = Dispatcher('f')
+
+    @f.register(object)
+    def _(x):
+        return 'default'
+
+    @f.register(int)
+    def _(x):
+        if x % 2 == 0:
+            return 'even'
+        else:
+            raise MDNotImplementedError()
+
+    assert f('hello') == 'default'  # default behavior
+    assert f(2) == 'even'          # specialized behavior
+    assert f(3) == 'default'       # fall bac to default behavior
+    assert raises(NotImplementedError, lambda: f(1, 2))
+
+
+def test_not_implemented_error():
+    f = Dispatcher('f')
+
+    @f.register(float)
+    def _(a):
+        raise MDNotImplementedError()
+
+    assert raises(NotImplementedError, lambda: f(1.0))
+
+def test_ambiguity_register_error_ignore_dup():
+    f = Dispatcher('f')
+
+    class A:
+        pass
+    class B(A):
+        pass
+    class C(A):
+        pass
+
+    # suppress warning for registering ambiguous signal
+    f.add((A, B), lambda x,y: None, ambiguity_register_error_ignore_dup)
+    f.add((B, A), lambda x,y: None, ambiguity_register_error_ignore_dup)
+    f.add((A, C), lambda x,y: None, ambiguity_register_error_ignore_dup)
+    f.add((C, A), lambda x,y: None, ambiguity_register_error_ignore_dup)
+
+    # raises error if ambiguous signal is passed
+    assert raises(NotImplementedError, lambda: f(B(), C()))

parrot/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.

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

@@ -0,0 +1,66 @@
+from sympy.external import import_module
+from sympy.utilities.decorator import doctest_depends_on
+
+from sympy.parsing.latex.lark import LarkLaTeXParser, TransformToSymPyExpr, parse_latex_lark # noqa
+
+from .errors import LaTeXParsingError  # noqa
+
+
+__doctest_requires__ = {('parse_latex',): ['antlr4', 'lark']}
+
+
+@doctest_depends_on(modules=('antlr4', 'lark'))
+def parse_latex(s, strict=False, backend="antlr"):
+    r"""Converts the input LaTeX 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.
+    backend : str, optional
+        Currently, there are two backends supported: ANTLR, and Lark.
+        The default setting is to use the ANTLR backend, which can be
+        changed to Lark if preferred.
+
+        Use ``backend="antlr"`` for the ANTLR-based parser, and
+        ``backend="lark"`` for the Lark-based parser.
+
+        The ``backend`` option is case-sensitive, and must be in
+        all lowercase.
+    strict : bool, optional
+        This option is only available with the ANTLR backend.
+
+        If True, raise an exception if the string cannot be parsed as
+        valid LaTeX. If False, try to recover gracefully from common
+        mistakes.
+
+    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
+    >>> func = parse_latex(r"\int_1^\alpha \dfrac{\mathrm{d}t}{t}", backend="lark")
+    >>> func.evalf(subs={"alpha": 2})
+    0.693147180559945
+    """
+
+    if backend == "antlr":
+        _latex = import_module(
+            'sympy.parsing.latex._parse_latex_antlr',
+            import_kwargs={'fromlist': ['X']})
+
+        if _latex is not None:
+            return _latex.parse_latex(s, strict)
+    elif backend == "lark":
+        return parse_latex_lark(s)
+    else:
+        raise NotImplementedError(f"Using the '{backend}' backend in the LaTeX" \
+                                   " parser is not supported.")

parrot/lib/python3.10/site-packages/sympy/parsing/latex/_build_latex_antlr.py

@@ -0,0 +1,91 @@
+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, "LaTeX.g4"))
+dir_latex_antlr = os.path.join(here, "_antlr")
+
+header = '''\
+# *** 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
+'''
+
+
+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_latex_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,
+        # for now, not generating these as latex2sympy did not use them
+        "-no-visitor",
+        "-no-listener",
+    ]
+
+    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 latex* but LaTeX*.* won't match them.
+    for path in (glob.glob(os.path.join(output_dir, "LaTeX*.*")) or
+        glob.glob(os.path.join(output_dir, "latex*.*"))):
+
+        # 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() + '\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()

parrot/lib/python3.10/site-packages/sympy/parsing/latex/_parse_latex_antlr.py

@@ -0,0 +1,607 @@
+# Ported from latex2sympy by @augustt198
+# https://github.com/augustt198/latex2sympy
+# See license in LICENSE.txt
+from importlib.metadata import version
+import sympy
+from sympy.external import import_module
+from sympy.printing.str import StrPrinter
+from sympy.physics.quantum.state import Bra, Ket
+
+from .errors import LaTeXParsingError
+
+
+LaTeXParser = LaTeXLexer = MathErrorListener = None
+
+try:
+    LaTeXParser = import_module('sympy.parsing.latex._antlr.latexparser',
+                                import_kwargs={'fromlist': ['LaTeXParser']}).LaTeXParser
+    LaTeXLexer = import_module('sympy.parsing.latex._antlr.latexlexer',
+                               import_kwargs={'fromlist': ['LaTeXLexer']}).LaTeXLexer
+except Exception:
+    pass
+
+ErrorListener = import_module('antlr4.error.ErrorListener',
+                              warn_not_installed=True,
+                              import_kwargs={'fromlist': ['ErrorListener']}
+                              )
+
+
+
+if ErrorListener:
+    class MathErrorListener(ErrorListener.ErrorListener):  # type:ignore # noqa:F811
+        def __init__(self, src):
+            super(ErrorListener.ErrorListener, self).__init__()
+            self.src = src
+
+        def syntaxError(self, recog, symbol, line, col, msg, e):
+            fmt = "%s\n%s\n%s"
+            marker = "~" * col + "^"
+
+            if msg.startswith("missing"):
+                err = fmt % (msg, self.src, marker)
+            elif msg.startswith("no viable"):
+                err = fmt % ("I expected something else here", self.src, marker)
+            elif msg.startswith("mismatched"):
+                names = LaTeXParser.literalNames
+                expected = [
+                    names[i] for i in e.getExpectedTokens() if i < len(names)
+                ]
+                if len(expected) < 10:
+                    expected = " ".join(expected)
+                    err = (fmt % ("I expected one of these: " + expected, self.src,
+                                  marker))
+                else:
+                    err = (fmt % ("I expected something else here", self.src,
+                                  marker))
+            else:
+                err = fmt % ("I don't understand this", self.src, marker)
+            raise LaTeXParsingError(err)
+
+
+def parse_latex(sympy, strict=False):
+    antlr4 = import_module('antlr4')
+
+    if None in [antlr4, MathErrorListener] or \
+            not version('antlr4-python3-runtime').startswith('4.11'):
+        raise ImportError("LaTeX parsing requires the antlr4 Python package,"
+                          " provided by pip (antlr4-python3-runtime) or"
+                          " conda (antlr-python-runtime), version 4.11")
+
+    sympy = sympy.strip()
+    matherror = MathErrorListener(sympy)
+
+    stream = antlr4.InputStream(sympy)
+    lex = LaTeXLexer(stream)
+    lex.removeErrorListeners()
+    lex.addErrorListener(matherror)
+
+    tokens = antlr4.CommonTokenStream(lex)
+    parser = LaTeXParser(tokens)
+
+    # remove default console error listener
+    parser.removeErrorListeners()
+    parser.addErrorListener(matherror)
+
+    relation = parser.math().relation()
+    if strict and (relation.start.start != 0 or relation.stop.stop != len(sympy) - 1):
+        raise LaTeXParsingError("Invalid LaTeX")
+    expr = convert_relation(relation)
+
+    return expr
+
+
+def convert_relation(rel):
+    if rel.expr():
+        return convert_expr(rel.expr())
+
+    lh = convert_relation(rel.relation(0))
+    rh = convert_relation(rel.relation(1))
+    if rel.LT():
+        return sympy.StrictLessThan(lh, rh)
+    elif rel.LTE():
+        return sympy.LessThan(lh, rh)
+    elif rel.GT():
+        return sympy.StrictGreaterThan(lh, rh)
+    elif rel.GTE():
+        return sympy.GreaterThan(lh, rh)
+    elif rel.EQUAL():
+        return sympy.Eq(lh, rh)
+    elif rel.NEQ():
+        return sympy.Ne(lh, rh)
+
+
+def convert_expr(expr):
+    return convert_add(expr.additive())
+
+
+def convert_add(add):
+    if add.ADD():
+        lh = convert_add(add.additive(0))
+        rh = convert_add(add.additive(1))
+        return sympy.Add(lh, rh, evaluate=False)
+    elif add.SUB():
+        lh = convert_add(add.additive(0))
+        rh = convert_add(add.additive(1))
+        if hasattr(rh, "is_Atom") and rh.is_Atom:
+            return sympy.Add(lh, -1 * rh, evaluate=False)
+        return sympy.Add(lh, sympy.Mul(-1, rh, evaluate=False), evaluate=False)
+    else:
+        return convert_mp(add.mp())
+
+
+def convert_mp(mp):
+    if hasattr(mp, 'mp'):
+        mp_left = mp.mp(0)
+        mp_right = mp.mp(1)
+    else:
+        mp_left = mp.mp_nofunc(0)
+        mp_right = mp.mp_nofunc(1)
+
+    if mp.MUL() or mp.CMD_TIMES() or mp.CMD_CDOT():
+        lh = convert_mp(mp_left)
+        rh = convert_mp(mp_right)
+        return sympy.Mul(lh, rh, evaluate=False)
+    elif mp.DIV() or mp.CMD_DIV() or mp.COLON():
+        lh = convert_mp(mp_left)
+        rh = convert_mp(mp_right)
+        return sympy.Mul(lh, sympy.Pow(rh, -1, evaluate=False), evaluate=False)
+    else:
+        if hasattr(mp, 'unary'):
+            return convert_unary(mp.unary())
+        else:
+            return convert_unary(mp.unary_nofunc())
+
+
+def convert_unary(unary):
+    if hasattr(unary, 'unary'):
+        nested_unary = unary.unary()
+    else:
+        nested_unary = unary.unary_nofunc()
+    if hasattr(unary, 'postfix_nofunc'):
+        first = unary.postfix()
+        tail = unary.postfix_nofunc()
+        postfix = [first] + tail
+    else:
+        postfix = unary.postfix()
+
+    if unary.ADD():
+        return convert_unary(nested_unary)
+    elif unary.SUB():
+        numabs = convert_unary(nested_unary)
+        # Use Integer(-n) instead of Mul(-1, n)
+        return -numabs
+    elif postfix:
+        return convert_postfix_list(postfix)
+
+
+def convert_postfix_list(arr, i=0):
+    if i >= len(arr):
+        raise LaTeXParsingError("Index out of bounds")
+
+    res = convert_postfix(arr[i])
+    if isinstance(res, sympy.Expr):
+        if i == len(arr) - 1:
+            return res  # nothing to multiply by
+        else:
+            if i > 0:
+                left = convert_postfix(arr[i - 1])
+                right = convert_postfix(arr[i + 1])
+                if isinstance(left, sympy.Expr) and isinstance(
+                        right, sympy.Expr):
+                    left_syms = convert_postfix(arr[i - 1]).atoms(sympy.Symbol)
+                    right_syms = convert_postfix(arr[i + 1]).atoms(
+                        sympy.Symbol)
+                    # if the left and right sides contain no variables and the
+                    # symbol in between is 'x', treat as multiplication.
+                    if not (left_syms or right_syms) and str(res) == 'x':
+                        return convert_postfix_list(arr, i + 1)
+            # multiply by next
+            return sympy.Mul(
+                res, convert_postfix_list(arr, i + 1), evaluate=False)
+    else:  # must be derivative
+        wrt = res[0]
+        if i == len(arr) - 1:
+            raise LaTeXParsingError("Expected expression for derivative")
+        else:
+            expr = convert_postfix_list(arr, i + 1)
+            return sympy.Derivative(expr, wrt)
+
+
+def do_subs(expr, at):
+    if at.expr():
+        at_expr = convert_expr(at.expr())
+        syms = at_expr.atoms(sympy.Symbol)
+        if len(syms) == 0:
+            return expr
+        elif len(syms) > 0:
+            sym = next(iter(syms))
+            return expr.subs(sym, at_expr)
+    elif at.equality():
+        lh = convert_expr(at.equality().expr(0))
+        rh = convert_expr(at.equality().expr(1))
+        return expr.subs(lh, rh)
+
+
+def convert_postfix(postfix):
+    if hasattr(postfix, 'exp'):
+        exp_nested = postfix.exp()
+    else:
+        exp_nested = postfix.exp_nofunc()
+
+    exp = convert_exp(exp_nested)
+    for op in postfix.postfix_op():
+        if op.BANG():
+            if isinstance(exp, list):
+                raise LaTeXParsingError("Cannot apply postfix to derivative")
+            exp = sympy.factorial(exp, evaluate=False)
+        elif op.eval_at():
+            ev = op.eval_at()
+            at_b = None
+            at_a = None
+            if ev.eval_at_sup():
+                at_b = do_subs(exp, ev.eval_at_sup())
+            if ev.eval_at_sub():
+                at_a = do_subs(exp, ev.eval_at_sub())
+            if at_b is not None and at_a is not None:
+                exp = sympy.Add(at_b, -1 * at_a, evaluate=False)
+            elif at_b is not None:
+                exp = at_b
+            elif at_a is not None:
+                exp = at_a
+
+    return exp
+
+
+def convert_exp(exp):
+    if hasattr(exp, 'exp'):
+        exp_nested = exp.exp()
+    else:
+        exp_nested = exp.exp_nofunc()
+
+    if exp_nested:
+        base = convert_exp(exp_nested)
+        if isinstance(base, list):
+            raise LaTeXParsingError("Cannot raise derivative to power")
+        if exp.atom():
+            exponent = convert_atom(exp.atom())
+        elif exp.expr():
+            exponent = convert_expr(exp.expr())
+        return sympy.Pow(base, exponent, evaluate=False)
+    else:
+        if hasattr(exp, 'comp'):
+            return convert_comp(exp.comp())
+        else:
+            return convert_comp(exp.comp_nofunc())
+
+
+def convert_comp(comp):
+    if comp.group():
+        return convert_expr(comp.group().expr())
+    elif comp.abs_group():
+        return sympy.Abs(convert_expr(comp.abs_group().expr()), evaluate=False)
+    elif comp.atom():
+        return convert_atom(comp.atom())
+    elif comp.floor():
+        return convert_floor(comp.floor())
+    elif comp.ceil():
+        return convert_ceil(comp.ceil())
+    elif comp.func():
+        return convert_func(comp.func())
+
+
+def convert_atom(atom):
+    if atom.LETTER():
+        sname = atom.LETTER().getText()
+        if atom.subexpr():
+            if atom.subexpr().expr():  # subscript is expr
+                subscript = convert_expr(atom.subexpr().expr())
+            else:  # subscript is atom
+                subscript = convert_atom(atom.subexpr().atom())
+            sname += '_{' + StrPrinter().doprint(subscript) + '}'
+        if atom.SINGLE_QUOTES():
+            sname += atom.SINGLE_QUOTES().getText()  # put after subscript for easy identify
+        return sympy.Symbol(sname)
+    elif atom.SYMBOL():
+        s = atom.SYMBOL().getText()[1:]
+        if s == "infty":
+            return sympy.oo
+        else:
+            if atom.subexpr():
+                subscript = None
+                if atom.subexpr().expr():  # subscript is expr
+                    subscript = convert_expr(atom.subexpr().expr())
+                else:  # subscript is atom
+                    subscript = convert_atom(atom.subexpr().atom())
+                subscriptName = StrPrinter().doprint(subscript)
+                s += '_{' + subscriptName + '}'
+            return sympy.Symbol(s)
+    elif atom.number():
+        s = atom.number().getText().replace(",", "")
+        return sympy.Number(s)
+    elif atom.DIFFERENTIAL():
+        var = get_differential_var(atom.DIFFERENTIAL())
+        return sympy.Symbol('d' + var.name)
+    elif atom.mathit():
+        text = rule2text(atom.mathit().mathit_text())
+        return sympy.Symbol(text)
+    elif atom.frac():
+        return convert_frac(atom.frac())
+    elif atom.binom():
+        return convert_binom(atom.binom())
+    elif atom.bra():
+        val = convert_expr(atom.bra().expr())
+        return Bra(val)
+    elif atom.ket():
+        val = convert_expr(atom.ket().expr())
+        return Ket(val)
+
+
+def rule2text(ctx):
+    stream = ctx.start.getInputStream()
+    # starting index of starting token
+    startIdx = ctx.start.start
+    # stopping index of stopping token
+    stopIdx = ctx.stop.stop
+
+    return stream.getText(startIdx, stopIdx)
+
+
+def convert_frac(frac):
+    diff_op = False
+    partial_op = False
+    if frac.lower and frac.upper:
+        lower_itv = frac.lower.getSourceInterval()
+        lower_itv_len = lower_itv[1] - lower_itv[0] + 1
+        if (frac.lower.start == frac.lower.stop
+                and frac.lower.start.type == LaTeXLexer.DIFFERENTIAL):
+            wrt = get_differential_var_str(frac.lower.start.text)
+            diff_op = True
+        elif (lower_itv_len == 2 and frac.lower.start.type == LaTeXLexer.SYMBOL
+              and frac.lower.start.text == '\\partial'
+              and (frac.lower.stop.type == LaTeXLexer.LETTER
+                   or frac.lower.stop.type == LaTeXLexer.SYMBOL)):
+            partial_op = True
+            wrt = frac.lower.stop.text
+            if frac.lower.stop.type == LaTeXLexer.SYMBOL:
+                wrt = wrt[1:]
+
+        if diff_op or partial_op:
+            wrt = sympy.Symbol(wrt)
+            if (diff_op and frac.upper.start == frac.upper.stop
+                    and frac.upper.start.type == LaTeXLexer.LETTER
+                    and frac.upper.start.text == 'd'):
+                return [wrt]
+            elif (partial_op and frac.upper.start == frac.upper.stop
+                  and frac.upper.start.type == LaTeXLexer.SYMBOL
+                  and frac.upper.start.text == '\\partial'):
+                return [wrt]
+            upper_text = rule2text(frac.upper)
+
+            expr_top = None
+            if diff_op and upper_text.startswith('d'):
+                expr_top = parse_latex(upper_text[1:])
+            elif partial_op and frac.upper.start.text == '\\partial':
+                expr_top = parse_latex(upper_text[len('\\partial'):])
+            if expr_top:
+                return sympy.Derivative(expr_top, wrt)
+    if frac.upper:
+        expr_top = convert_expr(frac.upper)
+    else:
+        expr_top = sympy.Number(frac.upperd.text)
+    if frac.lower:
+        expr_bot = convert_expr(frac.lower)
+    else:
+        expr_bot = sympy.Number(frac.lowerd.text)
+    inverse_denom = sympy.Pow(expr_bot, -1, evaluate=False)
+    if expr_top == 1:
+        return inverse_denom
+    else:
+        return sympy.Mul(expr_top, inverse_denom, evaluate=False)
+
+def convert_binom(binom):
+    expr_n = convert_expr(binom.n)
+    expr_k = convert_expr(binom.k)
+    return sympy.binomial(expr_n, expr_k, evaluate=False)
+
+def convert_floor(floor):
+    val = convert_expr(floor.val)
+    return sympy.floor(val, evaluate=False)
+
+def convert_ceil(ceil):
+    val = convert_expr(ceil.val)
+    return sympy.ceiling(val, evaluate=False)
+
+def convert_func(func):
+    if func.func_normal():
+        if func.L_PAREN():  # function called with parenthesis
+            arg = convert_func_arg(func.func_arg())
+        else:
+            arg = convert_func_arg(func.func_arg_noparens())
+
+        name = func.func_normal().start.text[1:]
+
+        # change arc<trig> -> a<trig>
+        if name in [
+                "arcsin", "arccos", "arctan", "arccsc", "arcsec", "arccot"
+        ]:
+            name = "a" + name[3:]
+            expr = getattr(sympy.functions, name)(arg, evaluate=False)
+        if name in ["arsinh", "arcosh", "artanh"]:
+            name = "a" + name[2:]
+            expr = getattr(sympy.functions, name)(arg, evaluate=False)
+
+        if name == "exp":
+            expr = sympy.exp(arg, evaluate=False)
+
+        if name in ("log", "lg", "ln"):
+            if func.subexpr():
+                if func.subexpr().expr():
+                    base = convert_expr(func.subexpr().expr())
+                else:
+                    base = convert_atom(func.subexpr().atom())
+            elif name == "lg":  # ISO 80000-2:2019
+                base = 10
+            elif name in ("ln", "log"):  # SymPy's latex printer prints ln as log by default
+                base = sympy.E
+            expr = sympy.log(arg, base, evaluate=False)
+
+        func_pow = None
+        should_pow = True
+        if func.supexpr():
+            if func.supexpr().expr():
+                func_pow = convert_expr(func.supexpr().expr())
+            else:
+                func_pow = convert_atom(func.supexpr().atom())
+
+        if name in [
+                "sin", "cos", "tan", "csc", "sec", "cot", "sinh", "cosh",
+                "tanh"
+        ]:
+            if func_pow == -1:
+                name = "a" + name
+                should_pow = False
+            expr = getattr(sympy.functions, name)(arg, evaluate=False)
+
+        if func_pow and should_pow:
+            expr = sympy.Pow(expr, func_pow, evaluate=False)
+
+        return expr
+    elif func.LETTER() or func.SYMBOL():
+        if func.LETTER():
+            fname = func.LETTER().getText()
+        elif func.SYMBOL():
+            fname = func.SYMBOL().getText()[1:]
+        fname = str(fname)  # can't be unicode
+        if func.subexpr():
+            if func.subexpr().expr():  # subscript is expr
+                subscript = convert_expr(func.subexpr().expr())
+            else:  # subscript is atom
+                subscript = convert_atom(func.subexpr().atom())
+            subscriptName = StrPrinter().doprint(subscript)
+            fname += '_{' + subscriptName + '}'
+        if func.SINGLE_QUOTES():
+            fname += func.SINGLE_QUOTES().getText()
+        input_args = func.args()
+        output_args = []
+        while input_args.args():  # handle multiple arguments to function
+            output_args.append(convert_expr(input_args.expr()))
+            input_args = input_args.args()
+        output_args.append(convert_expr(input_args.expr()))
+        return sympy.Function(fname)(*output_args)
+    elif func.FUNC_INT():
+        return handle_integral(func)
+    elif func.FUNC_SQRT():
+        expr = convert_expr(func.base)
+        if func.root:
+            r = convert_expr(func.root)
+            return sympy.root(expr, r, evaluate=False)
+        else:
+            return sympy.sqrt(expr, evaluate=False)
+    elif func.FUNC_OVERLINE():
+        expr = convert_expr(func.base)
+        return sympy.conjugate(expr, evaluate=False)
+    elif func.FUNC_SUM():
+        return handle_sum_or_prod(func, "summation")
+    elif func.FUNC_PROD():
+        return handle_sum_or_prod(func, "product")
+    elif func.FUNC_LIM():
+        return handle_limit(func)
+
+
+def convert_func_arg(arg):
+    if hasattr(arg, 'expr'):
+        return convert_expr(arg.expr())
+    else:
+        return convert_mp(arg.mp_nofunc())
+
+
+def handle_integral(func):
+    if func.additive():
+        integrand = convert_add(func.additive())
+    elif func.frac():
+        integrand = convert_frac(func.frac())
+    else:
+        integrand = 1
+
+    int_var = None
+    if func.DIFFERENTIAL():
+        int_var = get_differential_var(func.DIFFERENTIAL())
+    else:
+        for sym in integrand.atoms(sympy.Symbol):
+            s = str(sym)
+            if len(s) > 1 and s[0] == 'd':
+                if s[1] == '\\':
+                    int_var = sympy.Symbol(s[2:])
+                else:
+                    int_var = sympy.Symbol(s[1:])
+                int_sym = sym
+        if int_var:
+            integrand = integrand.subs(int_sym, 1)
+        else:
+            # Assume dx by default
+            int_var = sympy.Symbol('x')
+
+    if func.subexpr():
+        if func.subexpr().atom():
+            lower = convert_atom(func.subexpr().atom())
+        else:
+            lower = convert_expr(func.subexpr().expr())
+        if func.supexpr().atom():
+            upper = convert_atom(func.supexpr().atom())
+        else:
+            upper = convert_expr(func.supexpr().expr())
+        return sympy.Integral(integrand, (int_var, lower, upper))
+    else:
+        return sympy.Integral(integrand, int_var)
+
+
+def handle_sum_or_prod(func, name):
+    val = convert_mp(func.mp())
+    iter_var = convert_expr(func.subeq().equality().expr(0))
+    start = convert_expr(func.subeq().equality().expr(1))
+    if func.supexpr().expr():  # ^{expr}
+        end = convert_expr(func.supexpr().expr())
+    else:  # ^atom
+        end = convert_atom(func.supexpr().atom())
+
+    if name == "summation":
+        return sympy.Sum(val, (iter_var, start, end))
+    elif name == "product":
+        return sympy.Product(val, (iter_var, start, end))
+
+
+def handle_limit(func):
+    sub = func.limit_sub()
+    if sub.LETTER():
+        var = sympy.Symbol(sub.LETTER().getText())
+    elif sub.SYMBOL():
+        var = sympy.Symbol(sub.SYMBOL().getText()[1:])
+    else:
+        var = sympy.Symbol('x')
+    if sub.SUB():
+        direction = "-"
+    elif sub.ADD():
+        direction = "+"
+    else:
+        direction = "+-"
+    approaching = convert_expr(sub.expr())
+    content = convert_mp(func.mp())
+
+    return sympy.Limit(content, var, approaching, direction)
+
+
+def get_differential_var(d):
+    text = get_differential_var_str(d.getText())
+    return sympy.Symbol(text)
+
+
+def get_differential_var_str(text):
+    for i in range(1, len(text)):
+        c = text[i]
+        if not (c == " " or c == "\r" or c == "\n" or c == "\t"):
+            idx = i
+            break
+    text = text[idx:]
+    if text[0] == "\\":
+        text = text[1:]
+    return text

parrot/lib/python3.10/site-packages/sympy/parsing/latex/errors.py

@@ -0,0 +1,2 @@
+class LaTeXParsingError(Exception):
+    pass

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

@@ -0,0 +1,2 @@
+from .latex_parser import parse_latex_lark, LarkLaTeXParser # noqa
+from .transformer import TransformToSymPyExpr # noqa

parrot/lib/python3.10/site-packages/sympy/parsing/sympy_parser.py

@@ -0,0 +1,1257 @@
+"""Transform a string with Python-like source code into SymPy expression. """
+
+from tokenize import (generate_tokens, untokenize, TokenError,
+    NUMBER, STRING, NAME, OP, ENDMARKER, ERRORTOKEN, NEWLINE)
+
+from keyword import iskeyword
+
+import ast
+import unicodedata
+from io import StringIO
+import builtins
+import types
+from typing import Tuple as tTuple, Dict as tDict, Any, Callable, \
+    List, Optional, Union as tUnion
+
+from sympy.assumptions.ask import AssumptionKeys
+from sympy.core.basic import Basic
+from sympy.core import Symbol
+from sympy.core.function import Function
+from sympy.utilities.misc import func_name
+from sympy.functions.elementary.miscellaneous import Max, Min
+
+
+null = ''
+
+TOKEN = tTuple[int, str]
+DICT = tDict[str, Any]
+TRANS = Callable[[List[TOKEN], DICT, DICT], List[TOKEN]]
+
+def _token_splittable(token_name: str) -> bool:
+    """
+    Predicate for whether a token name can be split into multiple tokens.
+
+    A token is splittable if it does not contain an underscore character and
+    it is not the name of a Greek letter. This is used to implicitly convert
+    expressions like 'xyz' into 'x*y*z'.
+    """
+    if '_' in token_name:
+        return False
+    try:
+        return not unicodedata.lookup('GREEK SMALL LETTER ' + token_name)
+    except KeyError:
+        return len(token_name) > 1
+
+
+def _token_callable(token: TOKEN, local_dict: DICT, global_dict: DICT, nextToken=None):
+    """
+    Predicate for whether a token name represents a callable function.
+
+    Essentially wraps ``callable``, but looks up the token name in the
+    locals and globals.
+    """
+    func = local_dict.get(token[1])
+    if not func:
+        func = global_dict.get(token[1])
+    return callable(func) and not isinstance(func, Symbol)
+
+
+def _add_factorial_tokens(name: str, result: List[TOKEN]) -> List[TOKEN]:
+    if result == [] or result[-1][1] == '(':
+        raise TokenError()
+
+    beginning = [(NAME, name), (OP, '(')]
+    end = [(OP, ')')]
+
+    diff = 0
+    length = len(result)
+
+    for index, token in enumerate(result[::-1]):
+        toknum, tokval = token
+        i = length - index - 1
+
+        if tokval == ')':
+            diff += 1
+        elif tokval == '(':
+            diff -= 1
+
+        if diff == 0:
+            if i - 1 >= 0 and result[i - 1][0] == NAME:
+                return result[:i - 1] + beginning + result[i - 1:] + end
+            else:
+                return result[:i] + beginning + result[i:] + end
+
+    return result
+
+
+class ParenthesisGroup(List[TOKEN]):
+    """List of tokens representing an expression in parentheses."""
+    pass
+
+
+class AppliedFunction:
+    """
+    A group of tokens representing a function and its arguments.
+
+    `exponent` is for handling the shorthand sin^2, ln^2, etc.
+    """
+    def __init__(self, function: TOKEN, args: ParenthesisGroup, exponent=None):
+        if exponent is None:
+            exponent = []
+        self.function = function
+        self.args = args
+        self.exponent = exponent
+        self.items = ['function', 'args', 'exponent']
+
+    def expand(self) -> List[TOKEN]:
+        """Return a list of tokens representing the function"""
+        return [self.function, *self.args]
+
+    def __getitem__(self, index):
+        return getattr(self, self.items[index])
+
+    def __repr__(self):
+        return "AppliedFunction(%s, %s, %s)" % (self.function, self.args,
+                                                self.exponent)
+
+
+def _flatten(result: List[tUnion[TOKEN, AppliedFunction]]):
+    result2: List[TOKEN] = []
+    for tok in result:
+        if isinstance(tok, AppliedFunction):
+            result2.extend(tok.expand())
+        else:
+            result2.append(tok)
+    return result2
+
+
+def _group_parentheses(recursor: TRANS):
+    def _inner(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+        """Group tokens between parentheses with ParenthesisGroup.
+
+        Also processes those tokens recursively.
+
+        """
+        result: List[tUnion[TOKEN, ParenthesisGroup]] = []
+        stacks: List[ParenthesisGroup] = []
+        stacklevel = 0
+        for token in tokens:
+            if token[0] == OP:
+                if token[1] == '(':
+                    stacks.append(ParenthesisGroup([]))
+                    stacklevel += 1
+                elif token[1] == ')':
+                    stacks[-1].append(token)
+                    stack = stacks.pop()
+
+                    if len(stacks) > 0:
+                        # We don't recurse here since the upper-level stack
+                        # would reprocess these tokens
+                        stacks[-1].extend(stack)
+                    else:
+                        # Recurse here to handle nested parentheses
+                        # Strip off the outer parentheses to avoid an infinite loop
+                        inner = stack[1:-1]
+                        inner = recursor(inner,
+                                         local_dict,
+                                         global_dict)
+                        parenGroup = [stack[0]] + inner + [stack[-1]]
+                        result.append(ParenthesisGroup(parenGroup))
+                    stacklevel -= 1
+                    continue
+            if stacklevel:
+                stacks[-1].append(token)
+            else:
+                result.append(token)
+        if stacklevel:
+            raise TokenError("Mismatched parentheses")
+        return result
+    return _inner
+
+
+def _apply_functions(tokens: List[tUnion[TOKEN, ParenthesisGroup]], local_dict: DICT, global_dict: DICT):
+    """Convert a NAME token + ParenthesisGroup into an AppliedFunction.
+
+    Note that ParenthesisGroups, if not applied to any function, are
+    converted back into lists of tokens.
+
+    """
+    result: List[tUnion[TOKEN, AppliedFunction]] = []
+    symbol = None
+    for tok in tokens:
+        if isinstance(tok, ParenthesisGroup):
+            if symbol and _token_callable(symbol, local_dict, global_dict):
+                result[-1] = AppliedFunction(symbol, tok)
+                symbol = None
+            else:
+                result.extend(tok)
+        elif tok[0] == NAME:
+            symbol = tok
+            result.append(tok)
+        else:
+            symbol = None
+            result.append(tok)
+    return result
+
+
+def _implicit_multiplication(tokens: List[tUnion[TOKEN, AppliedFunction]], local_dict: DICT, global_dict: DICT):
+    """Implicitly adds '*' tokens.
+
+    Cases:
+
+    - Two AppliedFunctions next to each other ("sin(x)cos(x)")
+
+    - AppliedFunction next to an open parenthesis ("sin x (cos x + 1)")
+
+    - A close parenthesis next to an AppliedFunction ("(x+2)sin x")\
+
+    - A close parenthesis next to an open parenthesis ("(x+2)(x+3)")
+
+    - AppliedFunction next to an implicitly applied function ("sin(x)cos x")
+
+    """
+    result: List[tUnion[TOKEN, AppliedFunction]] = []
+    skip = False
+    for tok, nextTok in zip(tokens, tokens[1:]):
+        result.append(tok)
+        if skip:
+            skip = False
+            continue
+        if tok[0] == OP and tok[1] == '.' and nextTok[0] == NAME:
+            # Dotted name. Do not do implicit multiplication
+            skip = True
+            continue
+        if isinstance(tok, AppliedFunction):
+            if isinstance(nextTok, AppliedFunction):
+                result.append((OP, '*'))
+            elif nextTok == (OP, '('):
+                # Applied function followed by an open parenthesis
+                if tok.function[1] == "Function":
+                    tok.function = (tok.function[0], 'Symbol')
+                result.append((OP, '*'))
+            elif nextTok[0] == NAME:
+                # Applied function followed by implicitly applied function
+                result.append((OP, '*'))
+        else:
+            if tok == (OP, ')'):
+                if isinstance(nextTok, AppliedFunction):
+                    # Close parenthesis followed by an applied function
+                    result.append((OP, '*'))
+                elif nextTok[0] == NAME:
+                    # Close parenthesis followed by an implicitly applied function
+                    result.append((OP, '*'))
+                elif nextTok == (OP, '('):
+                    # Close parenthesis followed by an open parenthesis
+                    result.append((OP, '*'))
+            elif tok[0] == NAME and not _token_callable(tok, local_dict, global_dict):
+                if isinstance(nextTok, AppliedFunction) or \
+                    (nextTok[0] == NAME and _token_callable(nextTok, local_dict, global_dict)):
+                    # Constant followed by (implicitly applied) function
+                    result.append((OP, '*'))
+                elif nextTok == (OP, '('):
+                    # Constant followed by parenthesis
+                    result.append((OP, '*'))
+                elif nextTok[0] == NAME:
+                    # Constant followed by constant
+                    result.append((OP, '*'))
+    if tokens:
+        result.append(tokens[-1])
+    return result
+
+
+def _implicit_application(tokens: List[tUnion[TOKEN, AppliedFunction]], local_dict: DICT, global_dict: DICT):
+    """Adds parentheses as needed after functions."""
+    result: List[tUnion[TOKEN, AppliedFunction]] = []
+    appendParen = 0  # number of closing parentheses to add
+    skip = 0  # number of tokens to delay before adding a ')' (to
+              # capture **, ^, etc.)
+    exponentSkip = False  # skipping tokens before inserting parentheses to
+                          # work with function exponentiation
+    for tok, nextTok in zip(tokens, tokens[1:]):
+        result.append(tok)
+        if (tok[0] == NAME and nextTok[0] not in [OP, ENDMARKER, NEWLINE]):
+            if _token_callable(tok, local_dict, global_dict, nextTok):  # type: ignore
+                result.append((OP, '('))
+                appendParen += 1
+        # name followed by exponent - function exponentiation
+        elif (tok[0] == NAME and nextTok[0] == OP and nextTok[1] == '**'):
+            if _token_callable(tok, local_dict, global_dict):  # type: ignore
+                exponentSkip = True
+        elif exponentSkip:
+            # if the last token added was an applied function (i.e. the
+            # power of the function exponent) OR a multiplication (as
+            # implicit multiplication would have added an extraneous
+            # multiplication)
+            if (isinstance(tok, AppliedFunction)
+                or (tok[0] == OP and tok[1] == '*')):
+                # don't add anything if the next token is a multiplication
+                # or if there's already a parenthesis (if parenthesis, still
+                # stop skipping tokens)
+                if not (nextTok[0] == OP and nextTok[1] == '*'):
+                    if not(nextTok[0] == OP and nextTok[1] == '('):
+                        result.append((OP, '('))
+                        appendParen += 1
+                    exponentSkip = False
+        elif appendParen:
+            if nextTok[0] == OP and nextTok[1] in ('^', '**', '*'):
+                skip = 1
+                continue
+            if skip:
+                skip -= 1
+                continue
+            result.append((OP, ')'))
+            appendParen -= 1
+
+    if tokens:
+        result.append(tokens[-1])
+
+    if appendParen:
+        result.extend([(OP, ')')] * appendParen)
+    return result
+
+
+def function_exponentiation(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """Allows functions to be exponentiated, e.g. ``cos**2(x)``.
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.sympy_parser import (parse_expr,
+    ... standard_transformations, function_exponentiation)
+    >>> transformations = standard_transformations + (function_exponentiation,)
+    >>> parse_expr('sin**4(x)', transformations=transformations)
+    sin(x)**4
+    """
+    result: List[TOKEN] = []
+    exponent: List[TOKEN] = []
+    consuming_exponent = False
+    level = 0
+    for tok, nextTok in zip(tokens, tokens[1:]):
+        if tok[0] == NAME and nextTok[0] == OP and nextTok[1] == '**':
+            if _token_callable(tok, local_dict, global_dict):
+                consuming_exponent = True
+        elif consuming_exponent:
+            if tok[0] == NAME and tok[1] == 'Function':
+                tok = (NAME, 'Symbol')
+            exponent.append(tok)
+
+            # only want to stop after hitting )
+            if tok[0] == nextTok[0] == OP and tok[1] == ')' and nextTok[1] == '(':
+                consuming_exponent = False
+            # if implicit multiplication was used, we may have )*( instead
+            if tok[0] == nextTok[0] == OP and tok[1] == '*' and nextTok[1] == '(':
+                consuming_exponent = False
+                del exponent[-1]
+            continue
+        elif exponent and not consuming_exponent:
+            if tok[0] == OP:
+                if tok[1] == '(':
+                    level += 1
+                elif tok[1] == ')':
+                    level -= 1
+            if level == 0:
+                result.append(tok)
+                result.extend(exponent)
+                exponent = []
+                continue
+        result.append(tok)
+    if tokens:
+        result.append(tokens[-1])
+    if exponent:
+        result.extend(exponent)
+    return result
+
+
+def split_symbols_custom(predicate: Callable[[str], bool]):
+    """Creates a transformation that splits symbol names.
+
+    ``predicate`` should return True if the symbol name is to be split.
+
+    For instance, to retain the default behavior but avoid splitting certain
+    symbol names, a predicate like this would work:
+
+
+    >>> from sympy.parsing.sympy_parser import (parse_expr, _token_splittable,
+    ... standard_transformations, implicit_multiplication,
+    ... split_symbols_custom)
+    >>> def can_split(symbol):
+    ...     if symbol not in ('list', 'of', 'unsplittable', 'names'):
+    ...             return _token_splittable(symbol)
+    ...     return False
+    ...
+    >>> transformation = split_symbols_custom(can_split)
+    >>> parse_expr('unsplittable', transformations=standard_transformations +
+    ... (transformation, implicit_multiplication))
+    unsplittable
+    """
+    def _split_symbols(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+        result: List[TOKEN] = []
+        split = False
+        split_previous=False
+
+        for tok in tokens:
+            if split_previous:
+                # throw out closing parenthesis of Symbol that was split
+                split_previous=False
+                continue
+            split_previous=False
+
+            if tok[0] == NAME and tok[1] in ['Symbol', 'Function']:
+                split = True
+
+            elif split and tok[0] == NAME:
+                symbol = tok[1][1:-1]
+
+                if predicate(symbol):
+                    tok_type = result[-2][1]  # Symbol or Function
+                    del result[-2:]  # Get rid of the call to Symbol
+
+                    i = 0
+                    while i < len(symbol):
+                        char = symbol[i]
+                        if char in local_dict or char in global_dict:
+                            result.append((NAME, "%s" % char))
+                        elif char.isdigit():
+                            chars = [char]
+                            for i in range(i + 1, len(symbol)):
+                                if not symbol[i].isdigit():
+                                  i -= 1
+                                  break
+                                chars.append(symbol[i])
+                            char = ''.join(chars)
+                            result.extend([(NAME, 'Number'), (OP, '('),
+                                           (NAME, "'%s'" % char), (OP, ')')])
+                        else:
+                            use = tok_type if i == len(symbol) else 'Symbol'
+                            result.extend([(NAME, use), (OP, '('),
+                                           (NAME, "'%s'" % char), (OP, ')')])
+                        i += 1
+
+                    # Set split_previous=True so will skip
+                    # the closing parenthesis of the original Symbol
+                    split = False
+                    split_previous = True
+                    continue
+
+                else:
+                    split = False
+
+            result.append(tok)
+
+        return result
+
+    return _split_symbols
+
+
+#: Splits symbol names for implicit multiplication.
+#:
+#: Intended to let expressions like ``xyz`` be parsed as ``x*y*z``. Does not
+#: split Greek character names, so ``theta`` will *not* become
+#: ``t*h*e*t*a``. Generally this should be used with
+#: ``implicit_multiplication``.
+split_symbols = split_symbols_custom(_token_splittable)
+
+
+def implicit_multiplication(tokens: List[TOKEN], local_dict: DICT,
+                            global_dict: DICT) -> List[TOKEN]:
+    """Makes the multiplication operator optional in most cases.
+
+    Use this before :func:`implicit_application`, otherwise expressions like
+    ``sin 2x`` will be parsed as ``x * sin(2)`` rather than ``sin(2*x)``.
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.sympy_parser import (parse_expr,
+    ... standard_transformations, implicit_multiplication)
+    >>> transformations = standard_transformations + (implicit_multiplication,)
+    >>> parse_expr('3 x y', transformations=transformations)
+    3*x*y
+    """
+    # These are interdependent steps, so we don't expose them separately
+    res1 = _group_parentheses(implicit_multiplication)(tokens, local_dict, global_dict)
+    res2 = _apply_functions(res1, local_dict, global_dict)
+    res3 = _implicit_multiplication(res2, local_dict, global_dict)
+    result = _flatten(res3)
+    return result
+
+
+def implicit_application(tokens: List[TOKEN], local_dict: DICT,
+                         global_dict: DICT) -> List[TOKEN]:
+    """Makes parentheses optional in some cases for function calls.
+
+    Use this after :func:`implicit_multiplication`, otherwise expressions
+    like ``sin 2x`` will be parsed as ``x * sin(2)`` rather than
+    ``sin(2*x)``.
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.sympy_parser import (parse_expr,
+    ... standard_transformations, implicit_application)
+    >>> transformations = standard_transformations + (implicit_application,)
+    >>> parse_expr('cot z + csc z', transformations=transformations)
+    cot(z) + csc(z)
+    """
+    res1 = _group_parentheses(implicit_application)(tokens, local_dict, global_dict)
+    res2 = _apply_functions(res1, local_dict, global_dict)
+    res3 = _implicit_application(res2, local_dict, global_dict)
+    result = _flatten(res3)
+    return result
+
+
+def implicit_multiplication_application(result: List[TOKEN], local_dict: DICT,
+                                        global_dict: DICT) -> List[TOKEN]:
+    """Allows a slightly relaxed syntax.
+
+    - Parentheses for single-argument method calls are optional.
+
+    - Multiplication is implicit.
+
+    - Symbol names can be split (i.e. spaces are not needed between
+      symbols).
+
+    - Functions can be exponentiated.
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.sympy_parser import (parse_expr,
+    ... standard_transformations, implicit_multiplication_application)
+    >>> parse_expr("10sin**2 x**2 + 3xyz + tan theta",
+    ... transformations=(standard_transformations +
+    ... (implicit_multiplication_application,)))
+    3*x*y*z + 10*sin(x**2)**2 + tan(theta)
+
+    """
+    for step in (split_symbols, implicit_multiplication,
+                 implicit_application, function_exponentiation):
+        result = step(result, local_dict, global_dict)
+
+    return result
+
+
+def auto_symbol(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """Inserts calls to ``Symbol``/``Function`` for undefined variables."""
+    result: List[TOKEN] = []
+    prevTok = (-1, '')
+
+    tokens.append((-1, ''))  # so zip traverses all tokens
+    for tok, nextTok in zip(tokens, tokens[1:]):
+        tokNum, tokVal = tok
+        nextTokNum, nextTokVal = nextTok
+        if tokNum == NAME:
+            name = tokVal
+
+            if (name in ['True', 'False', 'None']
+                    or iskeyword(name)
+                    # Don't convert attribute access
+                    or (prevTok[0] == OP and prevTok[1] == '.')
+                    # Don't convert keyword arguments
+                    or (prevTok[0] == OP and prevTok[1] in ('(', ',')
+                        and nextTokNum == OP and nextTokVal == '=')
+                    # the name has already been defined
+                    or name in local_dict and local_dict[name] is not null):
+                result.append((NAME, name))
+                continue
+            elif name in local_dict:
+                local_dict.setdefault(null, set()).add(name)
+                if nextTokVal == '(':
+                    local_dict[name] = Function(name)
+                else:
+                    local_dict[name] = Symbol(name)
+                result.append((NAME, name))
+                continue
+            elif name in global_dict:
+                obj = global_dict[name]
+                if isinstance(obj, (AssumptionKeys, Basic, type)) or callable(obj):
+                    result.append((NAME, name))
+                    continue
+
+            result.extend([
+                (NAME, 'Symbol' if nextTokVal != '(' else 'Function'),
+                (OP, '('),
+                (NAME, repr(str(name))),
+                (OP, ')'),
+            ])
+        else:
+            result.append((tokNum, tokVal))
+
+        prevTok = (tokNum, tokVal)
+
+    return result
+
+
+def lambda_notation(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """Substitutes "lambda" with its SymPy equivalent Lambda().
+    However, the conversion does not take place if only "lambda"
+    is passed because that is a syntax error.
+
+    """
+    result: List[TOKEN] = []
+    flag = False
+    toknum, tokval = tokens[0]
+    tokLen = len(tokens)
+
+    if toknum == NAME and tokval == 'lambda':
+        if tokLen == 2 or tokLen == 3 and tokens[1][0] == NEWLINE:
+            # In Python 3.6.7+, inputs without a newline get NEWLINE added to
+            # the tokens
+            result.extend(tokens)
+        elif tokLen > 2:
+            result.extend([
+                (NAME, 'Lambda'),
+                (OP, '('),
+                (OP, '('),
+                (OP, ')'),
+                (OP, ')'),
+            ])
+            for tokNum, tokVal in tokens[1:]:
+                if tokNum == OP and tokVal == ':':
+                    tokVal = ','
+                    flag = True
+                if not flag and tokNum == OP and tokVal in ('*', '**'):
+                    raise TokenError("Starred arguments in lambda not supported")
+                if flag:
+                    result.insert(-1, (tokNum, tokVal))
+                else:
+                    result.insert(-2, (tokNum, tokVal))
+    else:
+        result.extend(tokens)
+
+    return result
+
+
+def factorial_notation(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """Allows standard notation for factorial."""
+    result: List[TOKEN] = []
+    nfactorial = 0
+    for toknum, tokval in tokens:
+        if toknum == OP and tokval == "!":
+            # In Python 3.12 "!" are OP instead of ERRORTOKEN
+            nfactorial += 1
+        elif toknum == ERRORTOKEN:
+            op = tokval
+            if op == '!':
+                nfactorial += 1
+            else:
+                nfactorial = 0
+                result.append((OP, op))
+        else:
+            if nfactorial == 1:
+                result = _add_factorial_tokens('factorial', result)
+            elif nfactorial == 2:
+                result = _add_factorial_tokens('factorial2', result)
+            elif nfactorial > 2:
+                raise TokenError
+            nfactorial = 0
+            result.append((toknum, tokval))
+    return result
+
+
+def convert_xor(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """Treats XOR, ``^``, as exponentiation, ``**``."""
+    result: List[TOKEN] = []
+    for toknum, tokval in tokens:
+        if toknum == OP:
+            if tokval == '^':
+                result.append((OP, '**'))
+            else:
+                result.append((toknum, tokval))
+        else:
+            result.append((toknum, tokval))
+
+    return result
+
+
+def repeated_decimals(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """
+    Allows 0.2[1] notation to represent the repeated decimal 0.2111... (19/90)
+
+    Run this before auto_number.
+
+    """
+    result: List[TOKEN] = []
+
+    def is_digit(s):
+        return all(i in '0123456789_' for i in s)
+
+    # num will running match any DECIMAL [ INTEGER ]
+    num: List[TOKEN] = []
+    for toknum, tokval in tokens:
+        if toknum == NUMBER:
+            if (not num and '.' in tokval and 'e' not in tokval.lower() and
+                'j' not in tokval.lower()):
+                num.append((toknum, tokval))
+            elif is_digit(tokval)and  len(num) == 2:
+                num.append((toknum, tokval))
+            elif is_digit(tokval) and len(num) == 3 and is_digit(num[-1][1]):
+                # Python 2 tokenizes 00123 as '00', '123'
+                # Python 3 tokenizes 01289 as '012', '89'
+                num.append((toknum, tokval))
+            else:
+                num = []
+        elif toknum == OP:
+            if tokval == '[' and len(num) == 1:
+                num.append((OP, tokval))
+            elif tokval == ']' and len(num) >= 3:
+                num.append((OP, tokval))
+            elif tokval == '.' and not num:
+                # handle .[1]
+                num.append((NUMBER, '0.'))
+            else:
+                num = []
+        else:
+            num = []
+
+        result.append((toknum, tokval))
+
+        if num and num[-1][1] == ']':
+            # pre.post[repetend] = a + b/c + d/e where a = pre, b/c = post,
+            # and d/e = repetend
+            result = result[:-len(num)]
+            pre, post = num[0][1].split('.')
+            repetend = num[2][1]
+            if len(num) == 5:
+                repetend += num[3][1]
+
+            pre = pre.replace('_', '')
+            post = post.replace('_', '')
+            repetend = repetend.replace('_', '')
+
+            zeros = '0'*len(post)
+            post, repetends = [w.lstrip('0') for w in [post, repetend]]
+                                        # or else interpreted as octal
+
+            a = pre or '0'
+            b, c = post or '0', '1' + zeros
+            d, e = repetends, ('9'*len(repetend)) + zeros
+
+            seq = [
+                (OP, '('),
+                    (NAME, 'Integer'),
+                    (OP, '('),
+                        (NUMBER, a),
+                    (OP, ')'),
+                    (OP, '+'),
+                    (NAME, 'Rational'),
+                    (OP, '('),
+                        (NUMBER, b),
+                        (OP, ','),
+                        (NUMBER, c),
+                    (OP, ')'),
+                    (OP, '+'),
+                    (NAME, 'Rational'),
+                    (OP, '('),
+                        (NUMBER, d),
+                        (OP, ','),
+                        (NUMBER, e),
+                    (OP, ')'),
+                (OP, ')'),
+            ]
+            result.extend(seq)
+            num = []
+
+    return result
+
+
+def auto_number(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """
+    Converts numeric literals to use SymPy equivalents.
+
+    Complex numbers use ``I``, integer literals use ``Integer``, and float
+    literals use ``Float``.
+
+    """
+    result: List[TOKEN] = []
+
+    for toknum, tokval in tokens:
+        if toknum == NUMBER:
+            number = tokval
+            postfix = []
+
+            if number.endswith(('j', 'J')):
+                number = number[:-1]
+                postfix = [(OP, '*'), (NAME, 'I')]
+
+            if '.' in number or (('e' in number or 'E' in number) and
+                    not (number.startswith(('0x', '0X')))):
+                seq = [(NAME, 'Float'), (OP, '('),
+                    (NUMBER, repr(str(number))), (OP, ')')]
+            else:
+                seq = [(NAME, 'Integer'), (OP, '('), (
+                    NUMBER, number), (OP, ')')]
+
+            result.extend(seq + postfix)
+        else:
+            result.append((toknum, tokval))
+
+    return result
+
+
+def rationalize(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """Converts floats into ``Rational``. Run AFTER ``auto_number``."""
+    result: List[TOKEN] = []
+    passed_float = False
+    for toknum, tokval in tokens:
+        if toknum == NAME:
+            if tokval == 'Float':
+                passed_float = True
+                tokval = 'Rational'
+            result.append((toknum, tokval))
+        elif passed_float == True and toknum == NUMBER:
+            passed_float = False
+            result.append((STRING, tokval))
+        else:
+            result.append((toknum, tokval))
+
+    return result
+
+
+def _transform_equals_sign(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """Transforms the equals sign ``=`` to instances of Eq.
+
+    This is a helper function for ``convert_equals_signs``.
+    Works with expressions containing one equals sign and no
+    nesting. Expressions like ``(1=2)=False`` will not work with this
+    and should be used with ``convert_equals_signs``.
+
+    Examples: 1=2     to Eq(1,2)
+              1*2=x   to Eq(1*2, x)
+
+    This does not deal with function arguments yet.
+
+    """
+    result: List[TOKEN] = []
+    if (OP, "=") in tokens:
+        result.append((NAME, "Eq"))
+        result.append((OP, "("))
+        for token in tokens:
+            if token == (OP, "="):
+                result.append((OP, ","))
+                continue
+            result.append(token)
+        result.append((OP, ")"))
+    else:
+        result = tokens
+    return result
+
+
+def convert_equals_signs(tokens: List[TOKEN], local_dict: DICT,
+                         global_dict: DICT) -> List[TOKEN]:
+    """ Transforms all the equals signs ``=`` to instances of Eq.
+
+    Parses the equals signs in the expression and replaces them with
+    appropriate Eq instances. Also works with nested equals signs.
+
+    Does not yet play well with function arguments.
+    For example, the expression ``(x=y)`` is ambiguous and can be interpreted
+    as x being an argument to a function and ``convert_equals_signs`` will not
+    work for this.
+
+    See also
+    ========
+    convert_equality_operators
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.sympy_parser import (parse_expr,
+    ... standard_transformations, convert_equals_signs)
+    >>> parse_expr("1*2=x", transformations=(
+    ... standard_transformations + (convert_equals_signs,)))
+    Eq(2, x)
+    >>> parse_expr("(1*2=x)=False", transformations=(
+    ... standard_transformations + (convert_equals_signs,)))
+    Eq(Eq(2, x), False)
+
+    """
+    res1 = _group_parentheses(convert_equals_signs)(tokens, local_dict, global_dict)
+    res2 = _apply_functions(res1, local_dict, global_dict)
+    res3 = _transform_equals_sign(res2, local_dict, global_dict)
+    result = _flatten(res3)
+    return result
+
+
+#: Standard transformations for :func:`parse_expr`.
+#: Inserts calls to :class:`~.Symbol`, :class:`~.Integer`, and other SymPy
+#: datatypes and allows the use of standard factorial notation (e.g. ``x!``).
+standard_transformations: tTuple[TRANS, ...] \
+    = (lambda_notation, auto_symbol, repeated_decimals, auto_number,
+       factorial_notation)
+
+
+def stringify_expr(s: str, local_dict: DICT, global_dict: DICT,
+        transformations: tTuple[TRANS, ...]) -> str:
+    """
+    Converts the string ``s`` to Python code, in ``local_dict``
+
+    Generally, ``parse_expr`` should be used.
+    """
+
+    tokens = []
+    input_code = StringIO(s.strip())
+    for toknum, tokval, _, _, _ in generate_tokens(input_code.readline):
+        tokens.append((toknum, tokval))
+
+    for transform in transformations:
+        tokens = transform(tokens, local_dict, global_dict)
+
+    return untokenize(tokens)
+
+
+def eval_expr(code, local_dict: DICT, global_dict: DICT):
+    """
+    Evaluate Python code generated by ``stringify_expr``.
+
+    Generally, ``parse_expr`` should be used.
+    """
+    expr = eval(
+        code, global_dict, local_dict)  # take local objects in preference
+    return expr
+
+
+def parse_expr(s: str, local_dict: Optional[DICT] = None,
+               transformations: tUnion[tTuple[TRANS, ...], str] \
+                   = standard_transformations,
+               global_dict: Optional[DICT] = None, evaluate=True):
+    """Converts the string ``s`` to a SymPy expression, in ``local_dict``.
+
+    Parameters
+    ==========
+
+    s : str
+        The string to parse.
+
+    local_dict : dict, optional
+        A dictionary of local variables to use when parsing.
+
+    global_dict : dict, optional
+        A dictionary of global variables. By default, this is initialized
+        with ``from sympy import *``; provide this parameter to override
+        this behavior (for instance, to parse ``"Q & S"``).
+
+    transformations : tuple or str
+        A tuple of transformation functions used to modify the tokens of the
+        parsed expression before evaluation. The default transformations
+        convert numeric literals into their SymPy equivalents, convert
+        undefined variables into SymPy symbols, and allow the use of standard
+        mathematical factorial notation (e.g. ``x!``). Selection via
+        string is available (see below).
+
+    evaluate : bool, optional
+        When False, the order of the arguments will remain as they were in the
+        string and automatic simplification that would normally occur is
+        suppressed. (see examples)
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.sympy_parser import parse_expr
+    >>> parse_expr("1/2")
+    1/2
+    >>> type(_)
+    <class 'sympy.core.numbers.Half'>
+    >>> from sympy.parsing.sympy_parser import standard_transformations,\\
+    ... implicit_multiplication_application
+    >>> transformations = (standard_transformations +
+    ...     (implicit_multiplication_application,))
+    >>> parse_expr("2x", transformations=transformations)
+    2*x
+
+    When evaluate=False, some automatic simplifications will not occur:
+
+    >>> parse_expr("2**3"), parse_expr("2**3", evaluate=False)
+    (8, 2**3)
+
+    In addition the order of the arguments will not be made canonical.
+    This feature allows one to tell exactly how the expression was entered:
+
+    >>> a = parse_expr('1 + x', evaluate=False)
+    >>> b = parse_expr('x + 1', evaluate=0)
+    >>> a == b
+    False
+    >>> a.args
+    (1, x)
+    >>> b.args
+    (x, 1)
+
+    Note, however, that when these expressions are printed they will
+    appear the same:
+
+    >>> assert str(a) == str(b)
+
+    As a convenience, transformations can be seen by printing ``transformations``:
+
+    >>> from sympy.parsing.sympy_parser import transformations
+
+    >>> print(transformations)
+    0: lambda_notation
+    1: auto_symbol
+    2: repeated_decimals
+    3: auto_number
+    4: factorial_notation
+    5: implicit_multiplication_application
+    6: convert_xor
+    7: implicit_application
+    8: implicit_multiplication
+    9: convert_equals_signs
+    10: function_exponentiation
+    11: rationalize
+
+    The ``T`` object provides a way to select these transformations:
+
+    >>> from sympy.parsing.sympy_parser import T
+
+    If you print it, you will see the same list as shown above.
+
+    >>> str(T) == str(transformations)
+    True
+
+    Standard slicing will return a tuple of transformations:
+
+    >>> T[:5] == standard_transformations
+    True
+
+    So ``T`` can be used to specify the parsing transformations:
+
+    >>> parse_expr("2x", transformations=T[:5])
+    Traceback (most recent call last):
+    ...
+    SyntaxError: invalid syntax
+    >>> parse_expr("2x", transformations=T[:6])
+    2*x
+    >>> parse_expr('.3', transformations=T[3, 11])
+    3/10
+    >>> parse_expr('.3x', transformations=T[:])
+    3*x/10
+
+    As a further convenience, strings 'implicit' and 'all' can be used
+    to select 0-5 and all the transformations, respectively.
+
+    >>> parse_expr('.3x', transformations='all')
+    3*x/10
+
+    See Also
+    ========
+
+    stringify_expr, eval_expr, standard_transformations,
+    implicit_multiplication_application
+
+    """
+
+    if local_dict is None:
+        local_dict = {}
+    elif not isinstance(local_dict, dict):
+        raise TypeError('expecting local_dict to be a dict')
+    elif null in local_dict:
+        raise ValueError('cannot use "" in local_dict')
+
+    if global_dict is None:
+        global_dict = {}
+        exec('from sympy import *', global_dict)
+
+        builtins_dict = vars(builtins)
+        for name, obj in builtins_dict.items():
+            if isinstance(obj, types.BuiltinFunctionType):
+                global_dict[name] = obj
+        global_dict['max'] = Max
+        global_dict['min'] = Min
+
+    elif not isinstance(global_dict, dict):
+        raise TypeError('expecting global_dict to be a dict')
+
+    transformations = transformations or ()
+    if isinstance(transformations, str):
+        if transformations == 'all':
+            _transformations = T[:]
+        elif transformations == 'implicit':
+            _transformations = T[:6]
+        else:
+            raise ValueError('unknown transformation group name')
+    else:
+        _transformations = transformations
+
+    code = stringify_expr(s, local_dict, global_dict, _transformations)
+
+    if not evaluate:
+        code = compile(evaluateFalse(code), '<string>', 'eval') # type: ignore
+
+    try:
+        rv = eval_expr(code, local_dict, global_dict)
+        # restore neutral definitions for names
+        for i in local_dict.pop(null, ()):
+            local_dict[i] = null
+        return rv
+    except Exception as e:
+        # restore neutral definitions for names
+        for i in local_dict.pop(null, ()):
+            local_dict[i] = null
+        raise e from ValueError(f"Error from parse_expr with transformed code: {code!r}")
+
+
+def evaluateFalse(s: str):
+    """
+    Replaces operators with the SymPy equivalent and sets evaluate=False.
+    """
+    node = ast.parse(s)
+    transformed_node = EvaluateFalseTransformer().visit(node)
+    # node is a Module, we want an Expression
+    transformed_node = ast.Expression(transformed_node.body[0].value)
+
+    return ast.fix_missing_locations(transformed_node)
+
+
+class EvaluateFalseTransformer(ast.NodeTransformer):
+    operators = {
+        ast.Add: 'Add',
+        ast.Mult: 'Mul',
+        ast.Pow: 'Pow',
+        ast.Sub: 'Add',
+        ast.Div: 'Mul',
+        ast.BitOr: 'Or',
+        ast.BitAnd: 'And',
+        ast.BitXor: 'Not',
+    }
+    functions = (
+        'Abs', 'im', 're', 'sign', 'arg', 'conjugate',
+        'acos', 'acot', 'acsc', 'asec', 'asin', 'atan',
+        'acosh', 'acoth', 'acsch', 'asech', 'asinh', 'atanh',
+        'cos', 'cot', 'csc', 'sec', 'sin', 'tan',
+        'cosh', 'coth', 'csch', 'sech', 'sinh', 'tanh',
+        'exp', 'ln', 'log', 'sqrt', 'cbrt',
+    )
+
+    relational_operators = {
+        ast.NotEq: 'Ne',
+        ast.Lt: 'Lt',
+        ast.LtE: 'Le',
+        ast.Gt: 'Gt',
+        ast.GtE: 'Ge',
+        ast.Eq: 'Eq'
+    }
+    def visit_Compare(self, node):
+        if node.ops[0].__class__ in self.relational_operators:
+            sympy_class = self.relational_operators[node.ops[0].__class__]
+            right = self.visit(node.comparators[0])
+            left = self.visit(node.left)
+            new_node = ast.Call(
+                func=ast.Name(id=sympy_class, ctx=ast.Load()),
+                args=[left, right],
+                keywords=[ast.keyword(arg='evaluate', value=ast.Constant(value=False))]
+            )
+            return new_node
+        return node
+
+    def flatten(self, args, func):
+        result = []
+        for arg in args:
+            if isinstance(arg, ast.Call):
+                arg_func = arg.func
+                if isinstance(arg_func, ast.Call):
+                    arg_func = arg_func.func
+                if arg_func.id == func:
+                    result.extend(self.flatten(arg.args, func))
+                else:
+                    result.append(arg)
+            else:
+                result.append(arg)
+        return result
+
+    def visit_BinOp(self, node):
+        if node.op.__class__ in self.operators:
+            sympy_class = self.operators[node.op.__class__]
+            right = self.visit(node.right)
+            left = self.visit(node.left)
+
+            rev = False
+            if isinstance(node.op, ast.Sub):
+                right = ast.Call(
+                    func=ast.Name(id='Mul', ctx=ast.Load()),
+                    args=[ast.UnaryOp(op=ast.USub(), operand=ast.Constant(1)), right],
+                    keywords=[ast.keyword(arg='evaluate', value=ast.Constant(value=False))]
+                )
+            elif isinstance(node.op, ast.Div):
+                if isinstance(node.left, ast.UnaryOp):
+                    left, right = right, left
+                    rev = True
+                    left = ast.Call(
+                    func=ast.Name(id='Pow', ctx=ast.Load()),
+                    args=[left, ast.UnaryOp(op=ast.USub(), operand=ast.Constant(1))],
+                    keywords=[ast.keyword(arg='evaluate', value=ast.Constant(value=False))]
+                )
+                else:
+                    right = ast.Call(
+                    func=ast.Name(id='Pow', ctx=ast.Load()),
+                    args=[right, ast.UnaryOp(op=ast.USub(), operand=ast.Constant(1))],
+                    keywords=[ast.keyword(arg='evaluate', value=ast.Constant(value=False))]
+                )
+
+            if rev:  # undo reversal
+                left, right = right, left
+            new_node = ast.Call(
+                func=ast.Name(id=sympy_class, ctx=ast.Load()),
+                args=[left, right],
+                keywords=[ast.keyword(arg='evaluate', value=ast.Constant(value=False))]
+            )
+
+            if sympy_class in ('Add', 'Mul'):
+                # Denest Add or Mul as appropriate
+                new_node.args = self.flatten(new_node.args, sympy_class)
+
+            return new_node
+        return node
+
+    def visit_Call(self, node):
+        new_node = self.generic_visit(node)
+        if isinstance(node.func, ast.Name) and node.func.id in self.functions:
+            new_node.keywords.append(ast.keyword(arg='evaluate', value=ast.Constant(value=False)))
+        return new_node
+
+
+_transformation = {  # items can be added but never re-ordered
+0: lambda_notation,
+1: auto_symbol,
+2: repeated_decimals,
+3: auto_number,
+4: factorial_notation,
+5: implicit_multiplication_application,
+6: convert_xor,
+7: implicit_application,
+8: implicit_multiplication,
+9: convert_equals_signs,
+10: function_exponentiation,
+11: rationalize}
+
+transformations = '\n'.join('%s: %s' % (i, func_name(f)) for i, f in _transformation.items())
+
+
+class _T():
+    """class to retrieve transformations from a given slice
+
+    EXAMPLES
+    ========
+
+    >>> from sympy.parsing.sympy_parser import T, standard_transformations
+    >>> assert T[:5] == standard_transformations
+    """
+    def __init__(self):
+        self.N = len(_transformation)
+
+    def __str__(self):
+        return transformations
+
+    def __getitem__(self, t):
+        if not type(t) is tuple:
+            t = (t,)
+        i = []
+        for ti in t:
+            if type(ti) is int:
+                i.append(range(self.N)[ti])
+            elif type(ti) is slice:
+                i.extend(range(*ti.indices(self.N)))
+            else:
+                raise TypeError('unexpected slice arg')
+        return tuple([_transformation[_] for _ in i])
+
+T = _T()