ccxt-ir 4.3.46.0.3__py2.py3-none-any.whl → 4.5.0__py2.py3-none-any.whl

ccxt/async_support/base/ws/aiohttp_client.py

@@ -1,125 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import json
-from asyncio import sleep, ensure_future
-from aiohttp import WSMsgType
-from .functions import milliseconds, iso8601, is_json_encoded_object
-from ccxt.async_support.base.ws.client import Client
-from ccxt.async_support.base.ws.functions import gunzip, inflate
-from ccxt import NetworkError, RequestTimeout, ExchangeClosedByUser
-
-
-class AiohttpClient(Client):
-
-    proxy = None
-
-    def closed(self):
-        return (self.connection is None) or self.connection.closed
-
-    def receive(self):
-        return self.connection.receive()
-
-    # helper method for binary and text messages
-    def handle_text_or_binary_message(self, data):
-        if self.verbose:
-            self.log(iso8601(milliseconds()), 'message', data)
-        if isinstance(data, bytes):
-            data = data.decode()
-        decoded = json.loads(data) if is_json_encoded_object(data) else data
-        self.on_message_callback(self, decoded)
-
-    def handle_message(self, message):
-        # self.log(iso8601(milliseconds()), message)
-        if message.type == WSMsgType.TEXT:
-            self.handle_text_or_binary_message(message.data)
-        elif message.type == WSMsgType.BINARY:
-            data = message.data
-            if self.gunzip:
-                data = gunzip(data)
-            elif self.inflate:
-                data = inflate(data)
-            self.handle_text_or_binary_message(data)
-        # autoping is responsible for automatically replying with pong
-        # to a ping incoming from a server, we have to disable autoping
-        # with aiohttp's websockets and respond with pong manually
-        # otherwise aiohttp's websockets client won't trigger WSMsgType.PONG
-        elif message.type == WSMsgType.PING:
-            if self.verbose:
-                self.log(iso8601(milliseconds()), 'ping', message)
-            ensure_future(self.connection.pong(message.data), loop=self.asyncio_loop)
-        elif message.type == WSMsgType.PONG:
-            self.lastPong = milliseconds()
-            if self.verbose:
-                self.log(iso8601(milliseconds()), 'pong', message)
-            pass
-        elif message.type == WSMsgType.CLOSE:
-            if self.verbose:
-                self.log(iso8601(milliseconds()), 'close', self.closed(), message)
-            self.on_close(message.data)
-        elif message.type == WSMsgType.CLOSED:
-            if self.verbose:
-                self.log(iso8601(milliseconds()), 'closed', self.closed(), message)
-            self.on_close(1000)
-        elif message.type == WSMsgType.ERROR:
-            if self.verbose:
-                self.log(iso8601(milliseconds()), 'error', message)
-            error = NetworkError(str(message))
-            self.on_error(error)
-
-    def create_connection(self, session):
-        # autoping is responsible for automatically replying with pong
-        # to a ping incoming from a server, we have to disable autoping
-        # with aiohttp's websockets and respond with pong manually
-        # otherwise aiohttp's websockets client won't trigger WSMsgType.PONG
-        # call aenter here to simulate async with otherwise we get the error "await not called with future"
-        # if connecting to a non-existent endpoint
-        if (self.proxy):
-            return session.ws_connect(self.url, autoping=False, autoclose=False, headers=self.options.get('headers'), proxy=self.proxy).__aenter__()
-        return session.ws_connect(self.url, autoping=False, autoclose=False, headers=self.options.get('headers')).__aenter__()
-
-    async def send(self, message):
-        if self.verbose:
-            self.log(iso8601(milliseconds()), 'sending', message)
-        return await self.connection.send_str(message if isinstance(message, str) else json.dumps(message, separators=(',', ':')))
-
-    async def close(self, code=1000):
-        if self.verbose:
-            self.log(iso8601(milliseconds()), 'closing', code)
-        if not self.closed():
-            await self.connection.close()
-        # these will end automatically once self.closed() = True
-        # so we don't need to cancel them
-        if self.ping_looper:
-            self.ping_looper.cancel()
-        if self.receive_looper:
-            self.receive_looper.cancel()  # cancel all pending futures stored in self.futures
-        for key in self.futures:
-            future = self.futures[key]
-            if not future.done():
-                if future.is_race_future:
-                    future.cancel()  # this is an "internal" future so we want to cancel it silently
-                else:
-                    future.reject(ExchangeClosedByUser('Connection closed by the user'))
-
-
-    async def ping_loop(self):
-        if self.verbose:
-            self.log(iso8601(milliseconds()), 'ping loop')
-        while self.keepAlive and not self.closed():
-            now = milliseconds()
-            self.lastPong = now if self.lastPong is None else self.lastPong
-            if (self.lastPong + self.keepAlive * self.maxPingPongMisses) < now:
-                self.on_error(RequestTimeout('Connection to ' + self.url + ' timed out due to a ping-pong keepalive missing on time'))
-            # the following ping-clause is not necessary with aiohttp's built-in ws
-            # since it has a heartbeat option (see create_connection above)
-            # however some exchanges require a text-type ping message
-            # therefore we need this clause anyway
-            else:
-                if self.ping:
-                    try:
-                        await self.send(self.ping(self))
-                    except Exception as e:
-                        self.on_error(e)
-                else:
-                    await self.connection.ping()
-            await sleep(self.keepAlive / 1000)

ccxt/async_support/base/ws/fast_client.py

@@ -1,96 +0,0 @@
-"""A faster version of aiohttp's websocket client that uses select and other optimizations"""
-
-import asyncio
-import socket
-import collections
-from ccxt.async_support.base.ws.aiohttp_client import AiohttpClient
-
-
-class FastClient(AiohttpClient):
-    transport = None
-
-    def __init__(self, url, on_message_callback, on_error_callback, on_close_callback, on_connected_callback, config={}):
-        super(FastClient, self).__init__(url, on_message_callback, on_error_callback, on_close_callback, on_connected_callback, config)
-        # instead of using the deque in aiohttp we implement our own for speed
-        # https://github.com/aio-libs/aiohttp/blob/1d296d549050aa335ef542421b8b7dad788246d5/aiohttp/streams.py#L534
-        self.stack = collections.deque()
-        self.callback_scheduled = False
-
-    def receive_loop(self):
-        def handler():
-            if not self.stack:
-                self.callback_scheduled = False
-                return
-            message = self.stack.popleft()
-            try:
-                self.handle_message(message)
-            except Exception as error:
-                self.reject(error)
-            self.asyncio_loop.call_soon(handler)
-
-        def feed_data(message, size):
-            if not self.callback_scheduled:
-                self.callback_scheduled = True
-                self.asyncio_loop.call_soon(handler)
-            self.stack.append(message)
-
-        def feed_eof():
-            if self._close_code == 1000:  # OK close
-                self.on_close(1000)
-            else:
-                self.on_error(1006)  # ABNORMAL_CLOSURE
-
-        def wrapper(func):
-            def parse_frame(buf):
-                while self.stack:
-                    self.handle_message(self.stack.popleft())
-                return func(buf)
-            return parse_frame
-
-        async def close(code=1000, message=b''):
-            # this is needed because our other wrappers break the closing process
-            # we also don't wait for a response to the close message to speed it up
-            # this code is adapted from aiohttp client_ws.py
-            _self = self.connection
-            if not _self._closed:
-                _self._cancel_heartbeat()
-                _self._closed = True
-                try:
-                    await _self._writer.close(code, message)
-                    _self._response.close()
-                    self._close_code = 1000
-                except asyncio.CancelledError:
-                    _self._response.close()
-                    _self._close_code = 1006
-                    raise
-                except Exception as exc:
-                    _self._close_code = 1006
-                    _self._exception = exc
-            return True
-
-        connection = self.connection._conn
-        if connection.closed:
-            # connection got terminated after the connection was made and before the receive loop ran
-            self.on_close(1006)
-            return
-        self.transport = connection.transport
-        # increase the RCVBUF so that the tcp window size can be larger
-        sock = self.transport.get_extra_info('socket')
-        current_size = sock.getsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF)
-        # 2 mebibytes is a performance value
-        new_size = max(current_size, 2097152)
-        sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, new_size)
-
-        ws_reader = connection.protocol._payload_parser
-        ws_reader.parse_frame = wrapper(ws_reader.parse_frame)
-        ws_reader.queue.feed_data = feed_data
-        ws_reader.queue.feed_eof = feed_eof
-        self.connection.close = close
-        # return a future so super class won't complain
-        return asyncio.sleep(0)
-
-    def reset(self, error):
-        super(FastClient, self).reset(error)
-        self.stack.clear()
-        if self.transport:
-            self.transport.abort()

ccxt/async_support/bitbay.py

@@ -1,17 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# 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
-
-from ccxt.async_support.zonda import zonda
-from ccxt.abstract.bitbay import ImplicitAPI
-
-
-class bitbay(zonda, ImplicitAPI):
-
-    def describe(self):
-        return self.deep_extend(super(bitbay, self).describe(), {
-            'id': 'bitbay',
-            'name': 'BitBay',
-            'alias': True,
-        })

ccxt/async_support/bitcoincom.py

@@ -1,17 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# 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
-
-from ccxt.async_support.fmfwio import fmfwio
-from ccxt.abstract.bitcoincom import ImplicitAPI
-
-
-class bitcoincom(fmfwio, ImplicitAPI):
-
-    def describe(self):
-        return self.deep_extend(super(bitcoincom, self).describe(), {
-            'id': 'bitcoincom',
-            'name': 'Bitcoin.com',
-            'alias': True,
-        })