ccxt 4.2.76__py2.py3-none-any.whl → 4.4.48__py2.py3-none-any.whl

ccxt/static_dependencies/starkware/crypto/utils.py

@@ -0,0 +1,63 @@
+from typing import (
+    AsyncGenerator,
+    Optional,
+    TypeVar,
+)
+
+import sys
+
+if sys.version_info.minor >= 11:
+    from typing import Literal, ParamSpec
+else:
+    from typing_extensions import Literal, ParamSpec
+
+T = TypeVar("T")
+P = ParamSpec("P")
+K = TypeVar("K")
+V = TypeVar("V")
+TAsyncGenerator = TypeVar("TAsyncGenerator", bound=AsyncGenerator)
+NumType = TypeVar("NumType", int, float)
+HASH_BYTES = 32
+
+# If more shared types start popping up here extract to types.py.
+Endianness = Literal["big", "little"]
+TComparable = TypeVar("TComparable", bound="Comparable")
+
+def to_bytes(
+    value: int,
+    length: Optional[int] = None,
+    byte_order: Optional[Endianness] = None,
+    signed: Optional[bool] = None,
+) -> bytes:
+    """
+    Converts the given integer to a bytes object of given length and byte order.
+    The default values are 32B width (which is the hash result width) and 'big', respectively.
+    """
+    if length is None:
+        length = HASH_BYTES
+
+    if byte_order is None:
+        byte_order = "big"
+
+    if signed is None:
+        signed = False
+
+    return int.to_bytes(value, length=length, byteorder=byte_order, signed=signed)
+
+
+def from_bytes(
+    value: bytes,
+    byte_order: Optional[Endianness] = None,
+    signed: Optional[bool] = None,
+) -> int:
+    """
+    Converts the given bytes object (parsed according to the given byte order) to an integer.
+    Default byte order is 'big'.
+    """
+    if byte_order is None:
+        byte_order = "big"
+
+    if signed is None:
+        signed = False
+
+    return int.from_bytes(value, byteorder=byte_order, signed=signed)

ccxt/static_dependencies/sympy/core/intfunc.py

@@ -0,0 +1,35 @@
+"""
+The routines here were removed from numbers.py, power.py,
+digits.py and factor_.py so they could be imported into core
+without raising circular import errors.
+
+Although the name 'intfunc' was chosen to represent functions that
+work with integers, it can also be thought of as containing
+internal/core functions that are needed by the classes of the core.
+"""
+
+from ..external.gmpy import (gcdext)
+
+def igcdex(a, b):
+    """Returns x, y, g such that g = x*a + y*b = gcd(a, b).
+
+    Examples
+    ========
+
+    >>> from sympy.core.intfunc import igcdex
+    >>> igcdex(2, 3)
+    (-1, 1, 1)
+    >>> igcdex(10, 12)
+    (-1, 1, 2)
+
+    >>> x, y, g = igcdex(100, 2004)
+    >>> x, y, g
+    (-20, 1, 4)
+    >>> x*100 + y*2004
+    4
+
+    """
+    if (not a) and (not b):
+        return (0, 1, 0)
+    g, x, y = gcdext(int(a), int(b))
+    return x, y, g

ccxt/static_dependencies/sympy/external/gmpy.py

@@ -0,0 +1,345 @@
+import os
+from ctypes import c_long, sizeof
+from functools import reduce
+from typing import Tuple as tTuple, Type
+from warnings import warn
+
+from .importtools import import_module
+
+from .pythonmpq import PythonMPQ
+
+from .ntheory import (
+    # bit_scan1 as python_bit_scan1,
+    # bit_scan0 as python_bit_scan0,
+    # remove as python_remove,
+    # factorial as python_factorial,
+    # sqrt as python_sqrt,
+    # sqrtrem as python_sqrtrem,
+    # gcd as python_gcd,
+    # lcm as python_lcm,
+    gcdext as python_gcdext,
+    # is_square as python_is_square,
+    # invert as python_invert,
+    # legendre as python_legendre,
+    # jacobi as python_jacobi,
+    # kronecker as python_kronecker,
+    # iroot as python_iroot,
+    # is_fermat_prp as python_is_fermat_prp,
+    # is_euler_prp as python_is_euler_prp,
+    # is_strong_prp as python_is_strong_prp,
+    # is_fibonacci_prp as python_is_fibonacci_prp,
+    # is_lucas_prp as python_is_lucas_prp,
+    # is_selfridge_prp as python_is_selfridge_prp,
+    # is_strong_lucas_prp as python_is_strong_lucas_prp,
+    # is_strong_selfridge_prp as python_is_strong_selfridge_prp,
+    # is_bpsw_prp as python_is_bpsw_prp,
+    # is_strong_bpsw_prp as python_is_strong_bpsw_prp,
+)
+
+
+__all__ = [
+    # GROUND_TYPES is either 'gmpy' or 'python' depending on which is used. If
+    # gmpy is installed then it will be used unless the environment variable
+    # SYMPY_GROUND_TYPES is set to something other than 'auto', 'gmpy', or
+    # 'gmpy2'.
+    'GROUND_TYPES',
+
+    # If HAS_GMPY is 0, no supported version of gmpy is available. Otherwise,
+    # HAS_GMPY will be 2 for gmpy2 if GROUND_TYPES is 'gmpy'. It used to be
+    # possible for HAS_GMPY to be 1 for gmpy but gmpy is no longer supported.
+    'HAS_GMPY',
+
+    # SYMPY_INTS is a tuple containing the base types for valid integer types.
+    # This is either (int,) or (int, type(mpz(0))) depending on GROUND_TYPES.
+    'SYMPY_INTS',
+
+    # MPQ is either gmpy.mpq or the Python equivalent from
+    # sympy.external.pythonmpq
+    'MPQ',
+
+    # MPZ is either gmpy.mpz or int.
+    'MPZ',
+
+    # 'bit_scan1',
+    # 'bit_scan0',
+    # 'remove',
+    # 'factorial',
+    # 'sqrt',
+    # 'is_square',
+    # 'sqrtrem',
+    # 'gcd',
+    # 'lcm',
+    'gcdext',
+    # 'invert',
+    # 'legendre',
+    # 'jacobi',
+    # 'kronecker',
+    # 'iroot',
+    # 'is_fermat_prp',
+    # 'is_euler_prp',
+    # 'is_strong_prp',
+    # 'is_fibonacci_prp',
+    # 'is_lucas_prp',
+    # 'is_selfridge_prp',
+    # 'is_strong_lucas_prp',
+    # 'is_strong_selfridge_prp',
+    # 'is_bpsw_prp',
+    # 'is_strong_bpsw_prp',
+]
+
+
+#
+# Tested python-flint version. Future versions might work but we will only use
+# them if explicitly requested by SYMPY_GROUND_TYPES=flint.
+#
+_PYTHON_FLINT_VERSION_NEEDED = "0.6.*"
+
+
+def _flint_version_okay(flint_version):
+    flint_ver = flint_version.split('.')[:2]
+    needed_ver = _PYTHON_FLINT_VERSION_NEEDED.split('.')[:2]
+    return flint_ver == needed_ver
+
+#
+# We will only use gmpy2 >= 2.0.0
+#
+_GMPY2_MIN_VERSION = '2.0.0'
+
+
+def _get_flint(sympy_ground_types):
+    if sympy_ground_types not in ('auto', 'flint'):
+        return None
+
+    try:
+        import flint
+        # Earlier versions of python-flint may not have __version__.
+        from flint import __version__ as _flint_version
+    except ImportError:
+        if sympy_ground_types == 'flint':
+            warn("SYMPY_GROUND_TYPES was set to flint but python-flint is not "
+                 "installed. Falling back to other ground types.")
+        return None
+
+    if _flint_version_okay(_flint_version):
+        return flint
+    elif sympy_ground_types == 'auto':
+        warn(f"python-flint {_flint_version} is installed but only version "
+             f"{_PYTHON_FLINT_VERSION_NEEDED} will be used by default. "
+             f"Falling back to other ground types. Use "
+             f"SYMPY_GROUND_TYPES=flint to force the use of python-flint.")
+        return None
+    else:
+        warn(f"Using python-flint {_flint_version} because SYMPY_GROUND_TYPES "
+             f"is set to flint but this version of SymPy has only been tested "
+             f"with python-flint {_PYTHON_FLINT_VERSION_NEEDED}.")
+        return flint
+
+
+def _get_gmpy2(sympy_ground_types):
+    if sympy_ground_types not in ('auto', 'gmpy', 'gmpy2'):
+        return None
+
+    gmpy = import_module('gmpy2', min_module_version=_GMPY2_MIN_VERSION,
+            module_version_attr='version', module_version_attr_call_args=())
+
+    if sympy_ground_types != 'auto' and gmpy is None:
+        warn("gmpy2 library is not installed, switching to 'python' ground types")
+
+    return gmpy
+
+
+#
+# SYMPY_GROUND_TYPES can be flint, gmpy, gmpy2, python or auto (default)
+#
+_SYMPY_GROUND_TYPES = os.environ.get('SYMPY_GROUND_TYPES', 'auto').lower()
+_flint = None
+_gmpy = None
+
+#
+# First handle auto-detection of flint/gmpy2. We will prefer flint if available
+# or otherwise gmpy2 if available and then lastly the python types.
+#
+if _SYMPY_GROUND_TYPES in ('auto', 'flint'):
+    _flint = _get_flint(_SYMPY_GROUND_TYPES)
+    if _flint is not None:
+        _SYMPY_GROUND_TYPES = 'flint'
+    else:
+        _SYMPY_GROUND_TYPES = 'auto'
+
+if _SYMPY_GROUND_TYPES in ('auto', 'gmpy', 'gmpy2'):
+    _gmpy = _get_gmpy2(_SYMPY_GROUND_TYPES)
+    if _gmpy is not None:
+        _SYMPY_GROUND_TYPES = 'gmpy'
+    else:
+        _SYMPY_GROUND_TYPES = 'python'
+
+if _SYMPY_GROUND_TYPES not in ('flint', 'gmpy', 'python'):
+    warn("SYMPY_GROUND_TYPES environment variable unrecognised. "
+         "Should be 'auto', 'flint', 'gmpy', 'gmpy2' or 'python'.")
+    _SYMPY_GROUND_TYPES = 'python'
+
+#
+# At this point _SYMPY_GROUND_TYPES is either flint, gmpy or python. The blocks
+# below define the values exported by this module in each case.
+#
+
+#
+# In gmpy2 and flint, there are functions that take a long (or unsigned long)
+# argument. That is, it is not possible to input a value larger than that.
+#
+LONG_MAX = (1 << (8*sizeof(c_long) - 1)) - 1
+
+#
+# Type checkers are confused by what SYMPY_INTS is. There may be a better type
+# hint for this like Type[Integral] or something.
+#
+SYMPY_INTS: tTuple[Type, ...]
+
+if _SYMPY_GROUND_TYPES == 'gmpy':
+
+    assert _gmpy is not None
+
+    flint = None
+    gmpy = _gmpy
+
+    HAS_GMPY = 2
+    GROUND_TYPES = 'gmpy'
+    SYMPY_INTS = (int, type(gmpy.mpz(0)))
+    MPZ = gmpy.mpz
+    MPQ = gmpy.mpq
+
+    # bit_scan1 = gmpy.bit_scan1
+    # bit_scan0 = gmpy.bit_scan0
+    # remove = gmpy.remove
+    # factorial = gmpy.fac
+    # sqrt = gmpy.isqrt
+    # is_square = gmpy.is_square
+    # sqrtrem = gmpy.isqrt_rem
+    # gcd = gmpy.gcd
+    # lcm = gmpy.lcm
+    gcdext = gmpy.gcdext
+    # invert = gmpy.invert
+    # legendre = gmpy.legendre
+    # jacobi = gmpy.jacobi
+    # kronecker = gmpy.kronecker
+
+    # def iroot(x, n):
+    #     # In the latest gmpy2, the threshold for n is ULONG_MAX,
+    #     # but adjust to the older one.
+    #     if n <= LONG_MAX:
+    #         return gmpy.iroot(x, n)
+    #     return python_iroot(x, n)
+
+    # is_fermat_prp = gmpy.is_fermat_prp
+    # is_euler_prp = gmpy.is_euler_prp
+    # is_strong_prp = gmpy.is_strong_prp
+    # is_fibonacci_prp = gmpy.is_fibonacci_prp
+    # is_lucas_prp = gmpy.is_lucas_prp
+    # is_selfridge_prp = gmpy.is_selfridge_prp
+    # is_strong_lucas_prp = gmpy.is_strong_lucas_prp
+    # is_strong_selfridge_prp = gmpy.is_strong_selfridge_prp
+    # is_bpsw_prp = gmpy.is_bpsw_prp
+    # is_strong_bpsw_prp = gmpy.is_strong_bpsw_prp
+
+elif _SYMPY_GROUND_TYPES == 'flint':
+
+    assert _flint is not None
+
+    flint = _flint
+    gmpy = None
+
+    HAS_GMPY = 0
+    GROUND_TYPES = 'flint'
+    SYMPY_INTS = (int, flint.fmpz) # type: ignore
+    MPZ = flint.fmpz # type: ignore
+    MPQ = flint.fmpq # type: ignore
+
+    # bit_scan1 = python_bit_scan1
+    # bit_scan0 = python_bit_scan0
+    # remove = python_remove
+    # factorial = python_factorial
+
+    # def sqrt(x):
+    #     return flint.fmpz(x).isqrt()
+
+    # def is_square(x):
+    #     if x < 0:
+    #         return False
+    #     return flint.fmpz(x).sqrtrem()[1] == 0
+
+    # def sqrtrem(x):
+    #     return flint.fmpz(x).sqrtrem()
+
+    # def gcd(*args):
+    #     return reduce(flint.fmpz.gcd, args, flint.fmpz(0))
+
+    # def lcm(*args):
+    #     return reduce(flint.fmpz.lcm, args, flint.fmpz(1))
+
+    gcdext = python_gcdext
+    # invert = python_invert
+    # legendre = python_legendre
+
+    # def jacobi(x, y):
+    #     if y <= 0 or not y % 2:
+    #         raise ValueError("y should be an odd positive integer")
+    #     return flint.fmpz(x).jacobi(y)
+
+    # kronecker = python_kronecker
+
+    # def iroot(x, n):
+    #     if n <= LONG_MAX:
+    #         y = flint.fmpz(x).root(n)
+    #         return y, y**n == x
+    #     return python_iroot(x, n)
+
+    # is_fermat_prp = python_is_fermat_prp
+    # is_euler_prp = python_is_euler_prp
+    # is_strong_prp = python_is_strong_prp
+    # is_fibonacci_prp = python_is_fibonacci_prp
+    # is_lucas_prp = python_is_lucas_prp
+    # is_selfridge_prp = python_is_selfridge_prp
+    # is_strong_lucas_prp = python_is_strong_lucas_prp
+    # is_strong_selfridge_prp = python_is_strong_selfridge_prp
+    # is_bpsw_prp = python_is_bpsw_prp
+    # is_strong_bpsw_prp = python_is_strong_bpsw_prp
+
+elif _SYMPY_GROUND_TYPES == 'python':
+
+    flint = None
+    gmpy = None
+
+    HAS_GMPY = 0
+    GROUND_TYPES = 'python'
+    SYMPY_INTS = (int,)
+    MPZ = int
+    MPQ = PythonMPQ
+
+    # bit_scan1 = python_bit_scan1
+    # bit_scan0 = python_bit_scan0
+    # remove = python_remove
+    # factorial = python_factorial
+    # sqrt = python_sqrt
+    # is_square = python_is_square
+    # sqrtrem = python_sqrtrem
+    # gcd = python_gcd
+    # lcm = python_lcm
+    gcdext = python_gcdext
+    # invert = python_invert
+    # legendre = python_legendre
+    # jacobi = python_jacobi
+    # kronecker = python_kronecker
+    # iroot = python_iroot
+    # is_fermat_prp = python_is_fermat_prp
+    # is_euler_prp = python_is_euler_prp
+    # is_strong_prp = python_is_strong_prp
+    # is_fibonacci_prp = python_is_fibonacci_prp
+    # is_lucas_prp = python_is_lucas_prp
+    # is_selfridge_prp = python_is_selfridge_prp
+    # is_strong_lucas_prp = python_is_strong_lucas_prp
+    # is_strong_selfridge_prp = python_is_strong_selfridge_prp
+    # is_bpsw_prp = python_is_bpsw_prp
+    # is_strong_bpsw_prp = python_is_strong_bpsw_prp
+
+else:
+    assert False

ccxt/static_dependencies/sympy/external/importtools.py

@@ -0,0 +1,187 @@
+"""Tools to assist importing optional external modules."""
+
+import sys
+import re
+
+# Override these in the module to change the default warning behavior.
+# For example, you might set both to False before running the tests so that
+# warnings are not printed to the console, or set both to True for debugging.
+
+WARN_NOT_INSTALLED = None  # Default is False
+WARN_OLD_VERSION = None  # Default is True
+
+
+def __sympy_debug():
+    # helper function from sympy/__init__.py
+    # We don't just import SYMPY_DEBUG from that file because we don't want to
+    # import all of SymPy just to use this module.
+    import os
+    debug_str = os.getenv('SYMPY_DEBUG', 'False')
+    if debug_str in ('True', 'False'):
+        return eval(debug_str)
+    else:
+        raise RuntimeError("unrecognized value for SYMPY_DEBUG: %s" %
+                           debug_str)
+
+if __sympy_debug():
+    WARN_OLD_VERSION = True
+    WARN_NOT_INSTALLED = True
+
+
+_component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE)
+
+def version_tuple(vstring):
+    # Parse a version string to a tuple e.g. '1.2' -> (1, 2)
+    # Simplified from distutils.version.LooseVersion which was deprecated in
+    # Python 3.10.
+    components = []
+    for x in _component_re.split(vstring):
+        if x and x != '.':
+            try:
+                x = int(x)
+            except ValueError:
+                pass
+            components.append(x)
+    return tuple(components)
+
+
+def import_module(module, min_module_version=None, min_python_version=None,
+        warn_not_installed=None, warn_old_version=None,
+        module_version_attr='__version__', module_version_attr_call_args=None,
+        import_kwargs={}, catch=()):
+    """
+    Import and return a module if it is installed.
+
+    If the module is not installed, it returns None.
+
+    A minimum version for the module can be given as the keyword argument
+    min_module_version.  This should be comparable against the module version.
+    By default, module.__version__ is used to get the module version.  To
+    override this, set the module_version_attr keyword argument.  If the
+    attribute of the module to get the version should be called (e.g.,
+    module.version()), then set module_version_attr_call_args to the args such
+    that module.module_version_attr(*module_version_attr_call_args) returns the
+    module's version.
+
+    If the module version is less than min_module_version using the Python <
+    comparison, None will be returned, even if the module is installed. You can
+    use this to keep from importing an incompatible older version of a module.
+
+    You can also specify a minimum Python version by using the
+    min_python_version keyword argument.  This should be comparable against
+    sys.version_info.
+
+    If the keyword argument warn_not_installed is set to True, the function will
+    emit a UserWarning when the module is not installed.
+
+    If the keyword argument warn_old_version is set to True, the function will
+    emit a UserWarning when the library is installed, but cannot be imported
+    because of the min_module_version or min_python_version options.
+
+    Note that because of the way warnings are handled, a warning will be
+    emitted for each module only once.  You can change the default warning
+    behavior by overriding the values of WARN_NOT_INSTALLED and WARN_OLD_VERSION
+    in sympy.external.importtools.  By default, WARN_NOT_INSTALLED is False and
+    WARN_OLD_VERSION is True.
+
+    This function uses __import__() to import the module.  To pass additional
+    options to __import__(), use the import_kwargs keyword argument.  For
+    example, to import a submodule A.B, you must pass a nonempty fromlist option
+    to __import__.  See the docstring of __import__().
+
+    This catches ImportError to determine if the module is not installed.  To
+    catch additional errors, pass them as a tuple to the catch keyword
+    argument.
+
+    Examples
+    ========
+
+    >>> from sympy.external import import_module
+
+    >>> numpy = import_module('numpy')
+
+    >>> numpy = import_module('numpy', min_python_version=(2, 7),
+    ... warn_old_version=False)
+
+    >>> numpy = import_module('numpy', min_module_version='1.5',
+    ... warn_old_version=False) # numpy.__version__ is a string
+
+    >>> # gmpy does not have __version__, but it does have gmpy.version()
+
+    >>> gmpy = import_module('gmpy', min_module_version='1.14',
+    ... module_version_attr='version', module_version_attr_call_args=(),
+    ... warn_old_version=False)
+
+    >>> # To import a submodule, you must pass a nonempty fromlist to
+    >>> # __import__().  The values do not matter.
+    >>> p3 = import_module('mpl_toolkits.mplot3d',
+    ... import_kwargs={'fromlist':['something']})
+
+    >>> # matplotlib.pyplot can raise RuntimeError when the display cannot be opened
+    >>> matplotlib = import_module('matplotlib',
+    ... import_kwargs={'fromlist':['pyplot']}, catch=(RuntimeError,))
+
+    """
+    # keyword argument overrides default, and global variable overrides
+    # keyword argument.
+    warn_old_version = (WARN_OLD_VERSION if WARN_OLD_VERSION is not None
+        else warn_old_version or True)
+    warn_not_installed = (WARN_NOT_INSTALLED if WARN_NOT_INSTALLED is not None
+        else warn_not_installed or False)
+
+    import warnings
+
+    # Check Python first so we don't waste time importing a module we can't use
+    if min_python_version:
+        if sys.version_info < min_python_version:
+            if warn_old_version:
+                warnings.warn("Python version is too old to use %s "
+                    "(%s or newer required)" % (
+                        module, '.'.join(map(str, min_python_version))),
+                    UserWarning, stacklevel=2)
+            return
+
+    try:
+        mod = __import__(module, **import_kwargs)
+
+        ## there's something funny about imports with matplotlib and py3k. doing
+        ##    from matplotlib import collections
+        ## gives python's stdlib collections module. explicitly re-importing
+        ## the module fixes this.
+        from_list = import_kwargs.get('fromlist', ())
+        for submod in from_list:
+            if submod == 'collections' and mod.__name__ == 'matplotlib':
+                __import__(module + '.' + submod)
+    except ImportError:
+        if warn_not_installed:
+            warnings.warn("%s module is not installed" % module, UserWarning,
+                    stacklevel=2)
+        return
+    except catch as e:
+        if warn_not_installed:
+            warnings.warn(
+                "%s module could not be used (%s)" % (module, repr(e)),
+                stacklevel=2)
+        return
+
+    if min_module_version:
+        modversion = getattr(mod, module_version_attr)
+        if module_version_attr_call_args is not None:
+            modversion = modversion(*module_version_attr_call_args)
+        if version_tuple(modversion) < version_tuple(min_module_version):
+            if warn_old_version:
+                # Attempt to create a pretty string version of the version
+                if isinstance(min_module_version, str):
+                    verstr = min_module_version
+                elif isinstance(min_module_version, (tuple, list)):
+                    verstr = '.'.join(map(str, min_module_version))
+                else:
+                    # Either don't know what this is.  Hopefully
+                    # it's something that has a nice str version, like an int.
+                    verstr = str(min_module_version)
+                warnings.warn("%s version is too old to use "
+                    "(%s or newer required)" % (module, verstr),
+                    UserWarning, stacklevel=2)
+            return
+
+    return mod