coinex-api 0.0.2__py3-none-any.whl

coinex_api/ccxt/base/__init__.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+
+# MIT License
+# Copyright (c) 2017 Igor Kroitor
+# 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.
+
+from ccxt.base import errors
+from ccxt.base import exchange
+from ccxt.base import decimal_to_precision
+
+__all__ = exchange.__all__ + decimal_to_precision.__all__ + errors.__all__  # noqa: F405

coinex_api/ccxt/base/decimal_to_precision.py

@@ -0,0 +1,174 @@
+import decimal
+import numbers
+import itertools
+import re
+
+__all__ = [
+    'TRUNCATE',
+    'ROUND',
+    'ROUND_UP',
+    'ROUND_DOWN',
+    'DECIMAL_PLACES',
+    'SIGNIFICANT_DIGITS',
+    'TICK_SIZE',
+    'NO_PADDING',
+    'PAD_WITH_ZERO',
+    'decimal_to_precision',
+]
+
+
+# rounding mode
+TRUNCATE = 0
+ROUND = 1
+ROUND_UP = 2
+ROUND_DOWN = 3
+
+# digits counting mode
+DECIMAL_PLACES = 2
+SIGNIFICANT_DIGITS = 3
+TICK_SIZE = 4
+
+# padding mode
+NO_PADDING = 5
+PAD_WITH_ZERO = 6
+
+
+def decimal_to_precision(n, rounding_mode=ROUND, precision=None, counting_mode=DECIMAL_PLACES, padding_mode=NO_PADDING):
+    assert precision is not None
+    if counting_mode == TICK_SIZE:
+        assert(isinstance(precision, float) or isinstance(precision, decimal.Decimal) or isinstance(precision, numbers.Integral) or isinstance(precision, str))
+    else:
+        assert(isinstance(precision, numbers.Integral))
+    assert rounding_mode in [TRUNCATE, ROUND]
+    assert counting_mode in [DECIMAL_PLACES, SIGNIFICANT_DIGITS, TICK_SIZE]
+    assert padding_mode in [NO_PADDING, PAD_WITH_ZERO]
+
+    if isinstance(precision, str):
+        precision = float(precision)
+
+    context = decimal.getcontext()
+
+    if counting_mode != TICK_SIZE:
+        precision = min(context.prec - 2, precision)
+
+    # all default except decimal.Underflow (raised when a number is rounded to zero)
+    context.traps[decimal.Underflow] = True
+    context.rounding = decimal.ROUND_HALF_UP  # rounds 0.5 away from zero
+
+    dec = decimal.Decimal(str(n))
+    precision_dec = decimal.Decimal(str(precision))
+    string = '{:f}'.format(dec)  # convert to string using .format to avoid engineering notation
+    precise = None
+
+    def power_of_10(x):
+        return decimal.Decimal('10') ** (-x)
+
+    if precision < 0:
+        if counting_mode == TICK_SIZE:
+            raise ValueError('TICK_SIZE cant be used with negative numPrecisionDigits')
+        to_nearest = power_of_10(precision)
+        if rounding_mode == ROUND:
+            return "{:f}".format(to_nearest * decimal.Decimal(decimal_to_precision(dec / to_nearest, rounding_mode, 0, DECIMAL_PLACES, padding_mode)))
+        elif rounding_mode == TRUNCATE:
+            return decimal_to_precision(dec - dec % to_nearest, rounding_mode, 0, DECIMAL_PLACES, padding_mode)
+
+    if counting_mode == TICK_SIZE:
+        # python modulo with negative numbers behaves different than js/php, so use abs first
+        missing = abs(dec) % precision_dec
+        if missing != 0:
+            if rounding_mode == ROUND:
+                if dec > 0:
+                    if missing >= precision / 2:
+                        dec = dec - missing + precision_dec
+                    else:
+                        dec = dec - missing
+                else:
+                    if missing >= precision / 2:
+                        dec = dec + missing - precision_dec
+                    else:
+                        dec = dec + missing
+            elif rounding_mode == TRUNCATE:
+                if dec < 0:
+                    dec = dec + missing
+                else:
+                    dec = dec - missing
+        parts = re.sub(r'0+$', '', '{:f}'.format(precision_dec)).split('.')
+        if len(parts) > 1:
+            new_precision = len(parts[1])
+        else:
+            match = re.search(r'0+$', parts[0])
+            if match is None:
+                new_precision = 0
+            else:
+                new_precision = - len(match.group(0))
+        return decimal_to_precision('{:f}'.format(dec), ROUND, new_precision, DECIMAL_PLACES, padding_mode)
+
+    if rounding_mode == ROUND:
+        if counting_mode == DECIMAL_PLACES:
+            precise = '{:f}'.format(dec.quantize(power_of_10(precision)))  # ROUND_HALF_EVEN is default context
+        elif counting_mode == SIGNIFICANT_DIGITS:
+            q = precision - dec.adjusted() - 1
+            sigfig = power_of_10(q)
+            if q < 0:
+                string_to_precision = string[:precision]
+                # string_to_precision is '' when we have zero precision
+                below = sigfig * decimal.Decimal(string_to_precision if string_to_precision else '0')
+                above = below + sigfig
+                precise = '{:f}'.format(min((below, above), key=lambda x: abs(x - dec)))
+            else:
+                precise = '{:f}'.format(dec.quantize(sigfig))
+        if precise == ('-0.' + len(precise) * '0')[:2] or precise == '-0':
+            precise = precise[1:]
+
+    elif rounding_mode == TRUNCATE:
+        # Slice a string
+        if counting_mode == DECIMAL_PLACES:
+            before, after = string.split('.') if '.' in string else (string, '')
+            precise = before + '.' + after[:precision]
+        elif counting_mode == SIGNIFICANT_DIGITS:
+            if precision == 0:
+                return '0'
+            dot = string.index('.') if '.' in string else len(string)
+            start = dot - dec.adjusted()
+            end = start + precision
+            # need to clarify these conditionals
+            if dot >= end:
+                end -= 1
+            if precision >= len(string.replace('.', '')):
+                precise = string
+            else:
+                precise = string[:end].ljust(dot, '0')
+        if precise == ('-0.' + len(precise) * '0')[:3] or precise == '-0':
+            precise = precise[1:]
+        precise = precise.rstrip('.')
+
+    if padding_mode == NO_PADDING:
+        return precise.rstrip('0').rstrip('.') if '.' in precise else precise
+    elif padding_mode == PAD_WITH_ZERO:
+        if '.' in precise:
+            if counting_mode == DECIMAL_PLACES:
+                before, after = precise.split('.')
+                return before + '.' + after.ljust(precision, '0')
+
+            elif counting_mode == SIGNIFICANT_DIGITS:
+                fsfg = len(list(itertools.takewhile(lambda x: x == '.' or x == '0', precise)))
+                if '.' in precise[fsfg:]:
+                    precision += 1
+                return precise[:fsfg] + precise[fsfg:].rstrip('0').ljust(precision, '0')
+        else:
+            if counting_mode == SIGNIFICANT_DIGITS:
+                if precision > len(precise):
+                    return precise + '.' + (precision - len(precise)) * '0'
+            elif counting_mode == DECIMAL_PLACES:
+                if precision > 0:
+                    return precise + '.' + precision * '0'
+            return precise
+
+
+def number_to_string(x):
+    # avoids scientific notation for too large and too small numbers
+    if x is None:
+        return None
+    d = decimal.Decimal(str(x))
+    formatted = '{:f}'.format(d)
+    return formatted.rstrip('0').rstrip('.') if '.' in formatted else formatted

coinex_api/ccxt/base/errors.py

@@ -0,0 +1,267 @@
+# ----------------------------------------------------------------------------
+
+# PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+# https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+# EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+error_hierarchy = {
+    'BaseError': {
+        'ExchangeError': {
+            'AuthenticationError': {
+                'PermissionDenied': {
+                    'AccountNotEnabled': {},
+                },
+                'AccountSuspended': {},
+            },
+            'ArgumentsRequired': {},
+            'BadRequest': {
+                'BadSymbol': {},
+            },
+            'OperationRejected': {
+                'NoChange': {
+                    'MarginModeAlreadySet': {},
+                },
+                'MarketClosed': {},
+                'ManualInteractionNeeded': {},
+            },
+            'InsufficientFunds': {},
+            'InvalidAddress': {
+                'AddressPending': {},
+            },
+            'InvalidOrder': {
+                'OrderNotFound': {},
+                'OrderNotCached': {},
+                'OrderImmediatelyFillable': {},
+                'OrderNotFillable': {},
+                'DuplicateOrderId': {},
+                'ContractUnavailable': {},
+            },
+            'NotSupported': {},
+            'InvalidProxySettings': {},
+            'ExchangeClosedByUser': {},
+        },
+        'OperationFailed': {
+            'NetworkError': {
+                'DDoSProtection': {},
+                'RateLimitExceeded': {},
+                'ExchangeNotAvailable': {
+                    'OnMaintenance': {},
+                },
+                'InvalidNonce': {
+                    'ChecksumError': {},
+                },
+                'RequestTimeout': {},
+            },
+            'BadResponse': {
+                'NullResponse': {},
+            },
+            'CancelPending': {},
+        },
+        'UnsubscribeError': {},
+    },
+}
+
+
+class BaseError(Exception):
+    pass
+
+
+class ExchangeError(BaseError):
+    pass
+
+
+class AuthenticationError(ExchangeError):
+    pass
+
+
+class PermissionDenied(AuthenticationError):
+    pass
+
+
+class AccountNotEnabled(PermissionDenied):
+    pass
+
+
+class AccountSuspended(AuthenticationError):
+    pass
+
+
+class ArgumentsRequired(ExchangeError):
+    pass
+
+
+class BadRequest(ExchangeError):
+    pass
+
+
+class BadSymbol(BadRequest):
+    pass
+
+
+class OperationRejected(ExchangeError):
+    pass
+
+
+class NoChange(OperationRejected):
+    pass
+
+
+class MarginModeAlreadySet(NoChange):
+    pass
+
+
+class MarketClosed(OperationRejected):
+    pass
+
+
+class ManualInteractionNeeded(OperationRejected):
+    pass
+
+
+class InsufficientFunds(ExchangeError):
+    pass
+
+
+class InvalidAddress(ExchangeError):
+    pass
+
+
+class AddressPending(InvalidAddress):
+    pass
+
+
+class InvalidOrder(ExchangeError):
+    pass
+
+
+class OrderNotFound(InvalidOrder):
+    pass
+
+
+class OrderNotCached(InvalidOrder):
+    pass
+
+
+class OrderImmediatelyFillable(InvalidOrder):
+    pass
+
+
+class OrderNotFillable(InvalidOrder):
+    pass
+
+
+class DuplicateOrderId(InvalidOrder):
+    pass
+
+
+class ContractUnavailable(InvalidOrder):
+    pass
+
+
+class NotSupported(ExchangeError):
+    pass
+
+
+class InvalidProxySettings(ExchangeError):
+    pass
+
+
+class ExchangeClosedByUser(ExchangeError):
+    pass
+
+
+class OperationFailed(BaseError):
+    pass
+
+
+class NetworkError(OperationFailed):
+    pass
+
+
+class DDoSProtection(NetworkError):
+    pass
+
+
+class RateLimitExceeded(NetworkError):
+    pass
+
+
+class ExchangeNotAvailable(NetworkError):
+    pass
+
+
+class OnMaintenance(ExchangeNotAvailable):
+    pass
+
+
+class InvalidNonce(NetworkError):
+    pass
+
+
+class ChecksumError(InvalidNonce):
+    pass
+
+
+class RequestTimeout(NetworkError):
+    pass
+
+
+class BadResponse(OperationFailed):
+    pass
+
+
+class NullResponse(BadResponse):
+    pass
+
+
+class CancelPending(OperationFailed):
+    pass
+
+
+class UnsubscribeError(BaseError):
+    pass
+
+
+__all__ = [
+    'error_hierarchy',
+    'BaseError',
+    'ExchangeError',
+    'AuthenticationError',
+    'PermissionDenied',
+    'AccountNotEnabled',
+    'AccountSuspended',
+    'ArgumentsRequired',
+    'BadRequest',
+    'BadSymbol',
+    'OperationRejected',
+    'NoChange',
+    'MarginModeAlreadySet',
+    'MarketClosed',
+    'ManualInteractionNeeded',
+    'InsufficientFunds',
+    'InvalidAddress',
+    'AddressPending',
+    'InvalidOrder',
+    'OrderNotFound',
+    'OrderNotCached',
+    'OrderImmediatelyFillable',
+    'OrderNotFillable',
+    'DuplicateOrderId',
+    'ContractUnavailable',
+    'NotSupported',
+    'InvalidProxySettings',
+    'ExchangeClosedByUser',
+    'OperationFailed',
+    'NetworkError',
+    'DDoSProtection',
+    'RateLimitExceeded',
+    'ExchangeNotAvailable',
+    'OnMaintenance',
+    'InvalidNonce',
+    'ChecksumError',
+    'RequestTimeout',
+    'BadResponse',
+    'NullResponse',
+    'CancelPending',
+    'UnsubscribeError'
+]