symengine 0.14.1__cp314-cp314t-macosx_10_13_x86_64.whl

symengine/tests/test_var.py

@@ -0,0 +1,68 @@
+# Tests for var are in their own file, because var pollutes global namespace.
+
+from symengine import Symbol, var
+from symengine.test_utilities import raises
+# make z1 with call-depth = 1
+
+
+def _make_z1():
+    var("z1")
+
+# make z2 with call-depth = 2
+
+
+def __make_z2():
+    var("z2")
+
+
+def _make_z2():
+    __make_z2()
+
+
+def test_var():
+    var("a")
+    assert a == Symbol("a")
+
+    var("b bb cc zz _x")
+    assert b == Symbol("b")
+    assert bb == Symbol("bb")
+    assert cc == Symbol("cc")
+    assert zz == Symbol("zz")
+    assert _x == Symbol("_x")
+
+    v = var(['d', 'e', 'fg'])
+    assert d == Symbol('d')
+    assert e == Symbol('e')
+    assert fg == Symbol('fg')
+
+    # check return value
+    assert v == [d, e, fg]
+
+
+def test_var_global_namespace():
+    # see if var() really injects into global namespace
+    raises(NameError, lambda: z1)
+    _make_z1()
+    assert z1 == Symbol("z1")
+
+    raises(NameError, lambda: z2)
+    _make_z2()
+    assert z2 == Symbol("z2")
+
+
+def test_var_return():
+    raises(ValueError, lambda: var(''))
+    v2 = var('q')
+    v3 = var('q p')
+
+    assert v2 == Symbol('q')
+    assert v3 == (Symbol('q'), Symbol('p'))
+
+
+def test_var_accepts_comma():
+    v1 = var('x y z')
+    v2 = var('x,y,z')
+    v3 = var('x,y z')
+
+    assert v1 == v2
+    assert v1 == v3

symengine/utilities.py

@@ -0,0 +1,280 @@
+from .lib.symengine_wrapper import Symbol, Basic
+from itertools import combinations, permutations, product, product as cartes
+import re as _re
+import string
+import sys
+
+
+_range = _re.compile('([0-9]*:[0-9]+|[a-zA-Z]?:[a-zA-Z])')
+
+
+def symbols(names, **args):
+    r"""
+    Transform strings into instances of :class:`Symbol` class.
+    :func:`symbols` function returns a sequence of symbols with names taken
+    from ``names`` argument, which can be a comma or whitespace delimited
+    string, or a sequence of strings::
+        >>> from symengine import symbols
+        >>> x, y, z = symbols('x,y,z')
+        >>> a, b, c = symbols('a b c')
+    The type of output is dependent on the properties of input arguments::
+        >>> symbols('x')
+        x
+        >>> symbols('x,')
+        (x,)
+        >>> symbols('x,y')
+        (x, y)
+        >>> symbols(('a', 'b', 'c'))
+        (a, b, c)
+        >>> symbols(['a', 'b', 'c'])
+        [a, b, c]
+        >>> symbols(set(['a', 'b', 'c']))
+        set([a, b, c])
+    If an iterable container is needed for a single symbol, set the ``seq``
+    argument to ``True`` or terminate the symbol name with a comma::
+        >>> symbols('x', seq=True)
+        (x,)
+    To reduce typing, range syntax is supported to create indexed symbols.
+    Ranges are indicated by a colon and the type of range is determined by
+    the character to the right of the colon. If the character is a digit
+    then all contiguous digits to the left are taken as the nonnegative
+    starting value (or 0 if there is no digit left of the colon) and all
+    contiguous digits to the right are taken as 1 greater than the ending
+    value::
+        >>> symbols('x:10')
+        (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)
+        >>> symbols('x5:10')
+        (x5, x6, x7, x8, x9)
+        >>> symbols('x5(:2)')
+        (x50, x51)
+        >>> symbols('x5:10,y:5')
+        (x5, x6, x7, x8, x9, y0, y1, y2, y3, y4)
+        >>> symbols(('x5:10', 'y:5'))
+        ((x5, x6, x7, x8, x9), (y0, y1, y2, y3, y4))
+    If the character to the right of the colon is a letter, then the single
+    letter to the left (or 'a' if there is none) is taken as the start
+    and all characters in the lexicographic range *through* the letter to
+    the right are used as the range::
+        >>> symbols('x:z')
+        (x, y, z)
+        >>> symbols('x:c')  # null range
+        ()
+        >>> symbols('x(:c)')
+        (xa, xb, xc)
+        >>> symbols(':c')
+        (a, b, c)
+        >>> symbols('a:d, x:z')
+        (a, b, c, d, x, y, z)
+        >>> symbols(('a:d', 'x:z'))
+        ((a, b, c, d), (x, y, z))
+    Multiple ranges are supported; contiguous numerical ranges should be
+    separated by parentheses to disambiguate the ending number of one
+    range from the starting number of the next::
+        >>> symbols('x:2(1:3)')
+        (x01, x02, x11, x12)
+        >>> symbols(':3:2')  # parsing is from left to right
+        (00, 01, 10, 11, 20, 21)
+    Only one pair of parentheses surrounding ranges are removed, so to
+    include parentheses around ranges, double them. And to include spaces,
+    commas, or colons, escape them with a backslash::
+        >>> symbols('x((a:b))')
+        (x(a), x(b))
+        >>> symbols('x(:1\,:2)')  # or 'x((:1)\,(:2))'
+        (x(0,0), x(0,1))
+    """
+    result = []
+
+    if isinstance(names, str):
+        marker = 0
+        literals = [r'\,', r'\:', r'\ ']
+        for i in range(len(literals)):
+            lit = literals.pop(0)
+            if lit in names:
+                while chr(marker) in names:
+                    marker += 1
+                lit_char = chr(marker)
+                marker += 1
+                names = names.replace(lit, lit_char)
+                literals.append((lit_char, lit[1:]))
+
+        def literal(s):
+            if literals:
+                for c, l in literals:
+                    s = s.replace(c, l)
+            return s
+
+        names = names.strip()
+        as_seq = names.endswith(',')
+        if as_seq:
+            names = names[:-1].rstrip()
+        if not names:
+            raise ValueError('no symbols given')
+
+        # split on commas
+        names = [n.strip() for n in names.split(',')]
+        if not all(n for n in names):
+            raise ValueError('missing symbol between commas')
+        # split on spaces
+        for i in range(len(names) - 1, -1, -1):
+            names[i: i + 1] = names[i].split()
+
+        cls = args.pop('cls', Symbol)
+        seq = args.pop('seq', as_seq)
+
+        for name in names:
+            if not name:
+                raise ValueError('missing symbol')
+
+            if ':' not in name:
+                symbol = cls(literal(name), **args)
+                result.append(symbol)
+                continue
+
+            split = _range.split(name)
+            # remove 1 layer of bounding parentheses around ranges
+            for i in range(len(split) - 1):
+                if i and ':' in split[i] and split[i] != ':' and \
+                        split[i - 1].endswith('(') and \
+                        split[i + 1].startswith(')'):
+                    split[i - 1] = split[i - 1][:-1]
+                    split[i + 1] = split[i + 1][1:]
+            for i, s in enumerate(split):
+                if ':' in s:
+                    if s[-1].endswith(':'):
+                        raise ValueError('missing end range')
+                    a, b = s.split(':')
+                    if b[-1] in string.digits:
+                        a = 0 if not a else int(a)
+                        b = int(b)
+                        split[i] = [str(c) for c in range(a, b)]
+                    else:
+                        a = a or 'a'
+                        split[i] = [string.ascii_letters[c] for c in range(
+                            string.ascii_letters.index(a),
+                            string.ascii_letters.index(b) + 1)]  # inclusive
+                    if not split[i]:
+                        break
+                else:
+                    split[i] = [s]
+            else:
+                seq = True
+                if len(split) == 1:
+                    names = split[0]
+                else:
+                    names = [''.join(s) for s in cartes(*split)]
+                if literals:
+                    result.extend([cls(literal(s), **args) for s in names])
+                else:
+                    result.extend([cls(s, **args) for s in names])
+
+        if not seq and len(result) <= 1:
+            if not result:
+                return ()
+            return result[0]
+
+        return tuple(result)
+    else:
+        for name in names:
+            result.append(symbols(name, **args))
+
+        return type(names)(result)
+
+
+def var(names, **args):
+    """
+    Create symbols and inject them into the global namespace.
+
+    INPUT:
+-            s -- a string, either a single variable name, or
+-                 a space separated list of variable names, or
+-                 a list of variable names.
+
+    This calls :func:`symbols` with the same arguments and puts the results
+    into the *global* namespace. It's recommended not to use :func:`var` in
+    library code, where :func:`symbols` has to be used::
+
+    Examples
+    ========
+
+    >>> from symengine import var
+
+    >>> var('x')
+    x
+    >>> x
+    x
+
+    >>> var('a,ab,abc')
+    (a, ab, abc)
+    >>> abc
+    abc
+
+    See :func:`symbols` documentation for more details on what kinds of
+    arguments can be passed to :func:`var`.
+
+    """
+    def traverse(symbols, frame):
+        """Recursively inject symbols to the global namespace. """
+        for symbol in symbols:
+            if isinstance(symbol, Basic):
+                frame.f_globals[symbol.__str__()] = symbol
+            # Once we hace an undefined function class
+            # implemented, put a check for function here
+            else:
+                traverse(symbol, frame)
+
+    from inspect import currentframe
+    frame = currentframe().f_back
+
+    try:
+        syms = symbols(names, **args)
+
+        if syms is not None:
+            if isinstance(syms, Basic):
+                frame.f_globals[syms.__str__()] = syms
+            # Once we hace an undefined function class
+            # implemented, put a check for function here
+            else:
+                traverse(syms, frame)
+    finally:
+        del frame  # break cyclic dependencies as stated in inspect docs
+
+    return syms
+
+
+class NotIterable:
+    """
+    Use this as mixin when creating a class which is not supposed to return
+    true when iterable() is called on its instances. I.e. avoid infinite loop
+    when calling e.g. list() on the instance
+    """
+    pass
+
+
+def iterable(i, exclude=(str, dict, NotIterable)):
+    """
+    Return a boolean indicating whether ``i`` is SymPy iterable.
+    True also indicates that the iterator is finite, i.e. you e.g.
+    call list(...) on the instance.
+
+    When SymPy is working with iterables, it is almost always assuming
+    that the iterable is not a string or a mapping, so those are excluded
+    by default. If you want a pure Python definition, make exclude=None. To
+    exclude multiple items, pass them as a tuple.
+    """
+    try:
+        iter(i)
+    except TypeError:
+        return False
+    if exclude:
+        return not isinstance(i, exclude)
+    return True
+
+
+def is_sequence(i):
+    """
+    Return a boolean indicating whether ``i`` is a sequence in the SymPy
+    sense. If anything that fails the test below should be included as
+    being a sequence for your application, set 'include' to that object's
+    type; multiple types should be passed as a tuple of types.
+    """
+    return hasattr(i, '__getitem__') and iterable(i)

symengine-0.14.1.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: symengine
+Version: 0.14.1
+Summary: Python library providing wrappers to SymEngine
+Home-page: https://github.com/symengine/symengine.py
+Author: SymEngine development team
+Author-email: symengine@googlegroups.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9,<4
+License-File: LICENSE
+License-File: AUTHORS
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+
+SymEngine is a standalone fast C++ symbolic manipulation library.
+Optional thin Python wrappers (SymEngine) allow easy usage from Python and
+integration with SymPy and Sage.
+
+See https://github.com/symengine/symengine.py for information about License
+and dependencies of wheels
+

symengine-0.14.1.dist-info/RECORD

@@ -0,0 +1,78 @@
+symengine/functions.py,sha256=LNfGb-yI6aXo9BszdmJWfFjZhQFCSYF44fXGMDhLwb8,425
+symengine/test_utilities.py,sha256=Pk8RHape9EeGatC3nUE5M-IJoL-U3_WHRS6TdRVWg6g,3086
+symengine/__init__.py,sha256=4YfiCPDHEwlmrzp7S4Uvix_FUhGwSk3p1bEiHxPGi2o,2403
+symengine/sympy_compat.py,sha256=pmISwghw-gwE3yM-cpJ2gYWyzO43GQrFVAzeDCLeFRM,171
+symengine/utilities.py,sha256=bn22sbLtKRQVR_G17O4-iO3K7Bo2kOvRZnkjl7IPrR8,9604
+symengine/printing.py,sha256=BKOTrj3voT6enkYZYvimM32ibVcBdLNVF4eIgIjHHW8,1115
+symengine/tests/test_lambdify.py,sha256=06jS9ivhHnTlLSHOClU5YO-9zTTHQGomA85D-lauPQo,29318
+symengine/tests/test_sage.py,sha256=kp_UzeS6vuIlLIc6f3PnykdBMNVKP8k2lZppsX29aOI,5400
+symengine/tests/test_sympy_compat.py,sha256=T24NXeFuStVKvzfZU4HL26RxXkH_2CHCBvdpJsWOd8s,4959
+symengine/tests/test_solve.py,sha256=MnAdXm3ZyX09FnQixaMNDG7vqMX-rr46U9UF5BpBZoY,935
+symengine/tests/test_subs.py,sha256=HlX_iYSSWqJQmSg7x8vRckHgre7Pl8ly6HdbTU-GYTw,1810
+symengine/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+symengine/tests/test_matrices.py,sha256=RH-5dDBkTaM0_krJg2TqFQsM5k6LKK3MCC50gEhX5Ww,20648
+symengine/tests/test_series_expansion.py,sha256=GfgoubMmPB30nasMB6t9JR-5uVg3xYOk9oAWDr0DWYY,741
+symengine/tests/test_sympy_conv.py,sha256=uR_6ThIEyDSq-dbrlE8x52eC3wbdnij0tLbEokLqF04,27637
+symengine/tests/test_cse.py,sha256=9SMfCrdQ7ZDoTkbcOk28UhXD2ZDFFbDFiAxOjWM5Ofk,469
+symengine/tests/test_arit.py,sha256=VEigtuYdMjyHP04UMIOTtuI1yCKxoeKlGjO43MDZ-9E,5693
+symengine/tests/test_pickling.py,sha256=lkRqJkkmg8Cot9ng2WnoVkVQH_LyeOtqx-SZorqZLj0,1562
+symengine/tests/test_printing.py,sha256=9_t5rlV1NQUZvolvFKiuuCtpwjS_6hb8FBMXkoGKV-o,1286
+symengine/tests/test_functions.py,sha256=Ctw1o-I3JV3FFiT8SkFha0qXtm8LpI2hmsY2W5WeoG4,11575
+symengine/tests/test_dict_basic.py,sha256=ger2sexbuua1tAxc3JfXlXGrnG2iRAThxGLc01j3jGc,640
+symengine/tests/test_var.py,sha256=q-6R2GVi9AF5eD16jiy_kks2xH4ReUqudZ_S-Zf7O90,1286
+symengine/tests/test_expr.py,sha256=pjkUfuLSXQtAQv110uiF0hJJyw_8i3XXU2A-q51GHl0,1037
+symengine/tests/test_number.py,sha256=F3WIKwBwfWdyHaY7cu9yOtTm4AaGPO71s256tQih3dA,5041
+symengine/tests/test_sympify.py,sha256=yL8JRRdnocswCHQM0S38KDbLB_6VwgZJl3R_HB1M-v4,1868
+symengine/tests/test_ntheory.py,sha256=jMjJVc1pomRDOWXRqqhQTHHUE-npOki4KxKMvWg6m1k,6312
+symengine/tests/test_sets.py,sha256=QWcZHWlK5pD5SZrF72uhYZjhYXm4fbmV5OzrQwqYeYQ,4177
+symengine/tests/test_symbol.py,sha256=5ARwhVtox-fH5kSBgM8JuPbUJK4BJ3HCUo-LiVf39To,5296
+symengine/tests/test_logic.py,sha256=Htbekxw7rQgSShfbcBwZpEi-T7Tb3lZPJ8_kJQWI7as,3546
+symengine/tests/test_eval.py,sha256=xIPgDolURXLoc7qehkYKdr8F4reNz5b-Gy9ptJcTbCc,1743
+symengine/tests/__pycache__/test_logic.cpython-314.pyc,sha256=MyzEEfcB2T_shJ_zW0Mwl3NfRX7KvAaQbW8sassn3_A,8690
+symengine/tests/__pycache__/test_var.cpython-314.pyc,sha256=md8UVH-Z3UoGZyW-7-ng6uNb1bB7wuBi-9J6nyrjryw,3101
+symengine/tests/__pycache__/test_series_expansion.cpython-314.pyc,sha256=Gq_FIXpmsNJlxgbiZT_2zW_tfYei2zMzIdHoMHIij4Q,1956
+symengine/tests/__pycache__/test_eval.cpython-314.pyc,sha256=sqVx9QQyADagDfU31J1gZq6Rs9sETpuQtCWOH0KpR-A,5142
+symengine/tests/__pycache__/test_matrices.cpython-314.pyc,sha256=mKQRCX0SWUq5jmefaCbrATa0xqSIPaIyZLMsYyg1n0Q,43222
+symengine/tests/__pycache__/test_sympify.cpython-314.pyc,sha256=AMGYEYO6H04cr4q8wLcQRfhFZ74HIZTsRKEtAkVamWE,5155
+symengine/tests/__pycache__/test_symbol.cpython-314.pyc,sha256=Wsmjp1BMzrc3Dt38u0PZpiuWNboQNR2OBHE3ufViQ5Q,10084
+symengine/tests/__pycache__/test_functions.cpython-314.pyc,sha256=majMx6b8Ag7q5-a2udzulRmMoOEPsRKYl2Ohx-VIRiw,28312
+symengine/tests/__pycache__/test_printing.cpython-314.pyc,sha256=sBrueK-ZK_p_nWTsv3hXOH96JqNCHI_DqC12XoACsEk,3160
+symengine/tests/__pycache__/test_expr.cpython-314.pyc,sha256=Z__54c7o640Vhni18MLbLw6qrlQ42dQOKMNP-WUWlw4,2708
+symengine/tests/__pycache__/test_number.cpython-314.pyc,sha256=T9Un5BD-OF55637t0jqN0w_1B_URx5g7Y6eYLDSQKnI,10601
+symengine/tests/__pycache__/test_ntheory.cpython-314.pyc,sha256=oKPcnPBmTHwKBVjMEOUfxsAoVIx4kG3j3X9wj6KGaT8,15014
+symengine/tests/__pycache__/test_lambdify.cpython-314.pyc,sha256=yJ8WN1zG3GZktEFK0VPQbbcE3oSkXDznF-UsYLpmudA,68919
+symengine/tests/__pycache__/test_dict_basic.cpython-314.pyc,sha256=oo-EFRqG4McKazftUvwZM6Ht31ZM_ZqISa5H6D5urm8,1782
+symengine/tests/__pycache__/test_sympy_conv.cpython-314.pyc,sha256=kQBrqPx56DzJNQ-SL4ps6SBTNPBns3gAhANuac4fzp0,66001
+symengine/tests/__pycache__/test_arit.cpython-314.pyc,sha256=Pa94NgVWCqGYpm0UR-7Spk61KymOHBz-82oxOcaFT3g,16318
+symengine/tests/__pycache__/test_sets.cpython-314.pyc,sha256=WYD4YUzjVekgry1L08V3Xv5-msmkFJzVmpUofHyFYZQ,9102
+symengine/tests/__pycache__/test_pickling.cpython-314.pyc,sha256=BvMZYWYvoehkpchSAggJR-1S23zpSYdqq7jNdAJrhHY,4347
+symengine/tests/__pycache__/test_solve.cpython-314.pyc,sha256=4r36dvMZaL1Thpt82l7O5i1P-M6zmlrhbpgvpzelo6Y,2350
+symengine/tests/__pycache__/test_subs.cpython-314.pyc,sha256=wKRgF-Av9LO_9A3JK5FdF0nEmOa4nZ5BSc1xQm_o5gw,4861
+symengine/tests/__pycache__/__init__.cpython-314.pyc,sha256=eLZQ9cGJ_IahEr42uZP0qAxaSloPh-kPRFPFKmEVfVw,166
+symengine/tests/__pycache__/test_cse.cpython-314.pyc,sha256=8QoxucX3UGMYK3MbJLcrUNG5UBTnrLfzwfe7RAfkYiU,1227
+symengine/tests/__pycache__/test_sympy_compat.cpython-314.pyc,sha256=Av2hRwoWzQCu8os-FDInQKgAMNJ_ltqzWfED6pFH31c,11609
+symengine/tests/__pycache__/test_sage.cpython-314.pyc,sha256=kIkOYm8jqXevBlnAFrCI8SCB9MrxDQoDEgD_X7lya2M,10777
+symengine/__pycache__/utilities.cpython-314.pyc,sha256=2kGhq8LnsQVYrzUR_20ua5T1-UncPUX80F9hfvgq29c,11613
+symengine/__pycache__/sympy_compat.cpython-314.pyc,sha256=LEafBnlvY4cYPEtxU-eO-TyzLEDUlnypc0FLdcbPOOE,386
+symengine/__pycache__/printing.cpython-314.pyc,sha256=Vq_BsK7sHNByPBwsV1wqsAXNc55B7Kboc1pM9Q2EIkI,2037
+symengine/__pycache__/test_utilities.cpython-314.pyc,sha256=LqGYXD9ecU8z5kWi5q6GTT08PIVjmaMSMDGjoj97q9A,3505
+symengine/__pycache__/__init__.cpython-314.pyc,sha256=bfXAxKlf4nMvuVwsi2f9F-sjZEj7M6A_O4WmU2aVvOQ,4329
+symengine/__pycache__/functions.cpython-314.pyc,sha256=IKbmMfgKbi7CF_fWlRGRM3ivdlJQ82uQXScR4S2woQY,1045
+symengine/.dylibs/libflint.20.0.dylib,sha256=RVNLsOwe2mm9xyTXU0rgWlqoWHj_pBAN66ed5ic-UIg,12939344
+symengine/.dylibs/libmpc.3.dylib,sha256=DOX73EO5Yp6PCItFKEsw3vMGtu_uB0fTaVtDa5aCHCI,113408
+symengine/.dylibs/libz.1.3.1.dylib,sha256=I8VSdQ93YFgqi2syGx6xD2H9Uvnd0-gD1gILP5UQJGs,103424
+symengine/.dylibs/libgmp.10.dylib,sha256=3qA0jNnS-LBZjr92qp6eTjvOWDRrujtpDvjYHvRgZLA,625744
+symengine/.dylibs/libmpfr.6.dylib,sha256=hTowEeuaMukzB6ApaxBGfdas3QLeEbSVpSH-aLh070M,477232
+symengine/.dylibs/libzstd.1.5.7.dylib,sha256=TJuLFtsfLvGLA8PnYIfOxDdZ56HMa49qAeh2fwNKOeM,1002512
+symengine/lib/symengine.pxd,sha256=OroamiaClbihMgQK1QVAHeFMyfSW6TynaugoYWhhLAw,44619
+symengine/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+symengine/lib/pywrapper.h,sha256=5FeCXvth1dlnftGzPNYvSiUTcEl0eXCutJOZ5QgdVbg,8503
+symengine/lib/symengine_wrapper.cpython-314t-darwin.so,sha256=jwVmmSIQTJqdrhMtKRofFVI2Pz_LokVjfDnfB_3LTS0,54201456
+symengine/lib/symengine_wrapper.pxd,sha256=tyR6XjwXckcZqWjGk8iibwZNm6YhtqIU4BLwqKdJbHs,3313
+symengine/lib/__pycache__/__init__.cpython-314.pyc,sha256=DltYAqxLXUXem-HWJ-XQMT1uMEw2CutGDQIcZZy7z-Y,164
+symengine-0.14.1.dist-info/RECORD,,
+symengine-0.14.1.dist-info/WHEEL,sha256=UlOYVXZUoedBznR7TtcHLe8dLSyBBw50dixq5hWMaMI,139
+symengine-0.14.1.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+symengine-0.14.1.dist-info/METADATA,sha256=AYniqyfGIWVIkIjtV8YQQWpJTJFxLj_XxkE7i4S5pck,1335
+symengine-0.14.1.dist-info/licenses/LICENSE,sha256=-xvtDIH_TwP5gAwjI6rTRHZ2ofLSlrlHhxpjXIsY-NA,20487
+symengine-0.14.1.dist-info/licenses/AUTHORS,sha256=Cs77zqfNEGj1BZ_36dUoOcX2qfMhc7HzpgZQEYb3Juw,1710

symengine-0.14.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp314-cp314t-macosx_10_13_x86_64
+Generator: delocate 0.13.0
+

symengine-0.14.1.dist-info/licenses/AUTHORS

@@ -0,0 +1,41 @@
+All people who contributed to symengine.py by sending at least a patch or more
+(Note that this repository was a subfolder of symengine repo and early contributors
+to the python bindings maybe listed in AUTHORS of symengine repo).
+You can generate this file by: bin/update_authors.sh.
+
+Ondřej Čertík <ondrej@certik.us>
+Thilina Bandara Rathanyake <thilinarmtb@gmail.com>
+Isuru Fernando <isuruf@gmail.com>
+Sushant Hiray <hiraysushant@gmail.com>
+Peter Brady <petertbrady@gmail.com>
+Thilina Bandara Rathnayake <thilinarmtb@gmail.com>
+Shivam Vats <shivamvats.iitkgp@gmail.com>
+Sumith Kulal <sumith1896@gmail.com>
+Connor Behan <connor.behan@gmail.com>
+Ralf Stephan <ralf@ark.in-berlin.de>
+Björn Dahlgren <bjodah@gmail.com>
+Indrek Mandre <indrek@mare.ee>
+Abhinav Agarwal <abhinavagarwal1996@gmail.com>
+Matt Wala <wala1@illinois.edu>
+Shikhar Jaiswal <jaiswalshikhar87@gmail.com>
+Nilay Pochhi <pochhi.nilay@gmail.com>
+xoviat <xoviat@users.noreply.github.com>
+Jean-Christophe Fillion-Robin <jchris.fillionr@kitware.com>
+Moritz E. Beber <morbeb@biosustain.dtu.dk>
+Alan Hu <alanlh2@illinois.edu>
+Richard Otis <richard.otis@outlook.com>
+Erik Jansson Agnvall <erikjansson90@gmail.com>
+Simon Stelter <stelter@uni-bremen.de>
+Jialin Ma <marlin@inventati.org>
+Rikard Nordgren <rikard.nordgren@farmaci.uu.se>
+Rohit Goswami <rgoswami@ieee.org>
+Matthew Treinish <mtreinish@kortar.org>
+Michał Górny <mgorny@gentoo.org>
+Garming Sam <garming@catalyst.net.nz>
+Pieter Eendebak <pieter.eendebak@gmail.com>
+Ayush Kumar <ayushk7102@gmail.com>
+Christian Clauss <cclauss@me.com>
+Moraxyc <i@qaq.li>
+Aaron Miller <78561124+aaron-skydio@users.noreply.github.com>
+Firat Bezir <bezir.1@osu.edu>
+Adrian Ostrowski <adrian.ostrowski@intel.com>