class BTStack(object):
def __init__(self, pyusb_dev=None):
if not pyusb_dev:
pyusb_dev = \
pyusb_bt_sockets.find_first_bt_adapter_pyusb_device_or_raise()
self.hci_socket = pyusb_bt_sockets.PyUSBBluetoothHCISocket(pyusb_dev)
self.hci = HCIThread(self.hci_socket)
self.cb_thread = CallbackThread()
self.cb_thread.register_with_rx_thread(self.hci)
self.is_scannning_enabled = False
self.connection_mgr = ConnectionManager(
self.hci, self.cb_thread)
self.address = None
def start(self):
LOG.debug("BTStack start()")
# During reset, just ignore and eat all packets that might come in:
ignore_queue = Queue.Queue()
self.hci.add_packet_queue(lambda packet: True, ignore_queue)
self.hci.start()
self.hci.cmd_reset()
self.hci.remove_packet_queue(ignore_queue)
self.cb_thread.start()
self.hci.cmd_set_event_filter_clear_all_filters()
self.hci.cmd_set_event_mask()
self.hci.cmd_le_host_supported()
# "The LE_Read_Buffer_Size command must be issued by the Host before it
# sends any data to an LE Controller":
self.hci.cmd_le_read_buffer_size()
self.address = self.hci.cmd_read_bd_addr()
def start_scan(self):
assert self.is_scannning_enabled is False
self.hci.cmd_le_scan_params()
self.hci.cmd_le_scan_enable(True)
self.is_scannning_enabled = True
def stop_scan(self):
assert self.is_scannning_enabled is True
self.hci.cmd_le_scan_enable(False)
self.is_scannning_enabled = False
def connect(self, address):
return self.connection_mgr.connect(address)
def disconnect(self, connection):
self.connection_mgr.disconnect(connection)
def quit(self):
LOG.debug("BTStack quit()")
self.hci.cmd_reset()
self.hci.kill()
self.cb_thread.kill()
class BTStack(object):
def __init__(self, pyusb_dev=None):
if not pyusb_dev:
pyusb_dev = \
pyusb_bt_sockets.find_first_bt_adapter_pyusb_device_or_raise()
self.hci_socket = pyusb_bt_sockets.PyUSBBluetoothHCISocket(pyusb_dev)
self.hci = HCIThread(self.hci_socket)
self.cb_thread = CallbackThread()
self.cb_thread.register_with_rx_thread(self.hci)
self.is_scannning_enabled = False
self.connection_mgr = ConnectionManager(self.hci, self.cb_thread)
self.address = None
def start(self):
LOG.debug("BTStack start()")
# During reset, just ignore and eat all packets that might come in:
ignore_queue = Queue.Queue()
self.hci.add_packet_queue(lambda packet: True, ignore_queue)
self.hci.start()
self.hci.cmd_reset()
self.hci.remove_packet_queue(ignore_queue)
self.cb_thread.start()
self.hci.cmd_set_event_filter_clear_all_filters()
self.hci.cmd_set_event_mask()
self.hci.cmd_le_host_supported()
# "The LE_Read_Buffer_Size command must be issued by the Host before it
# sends any data to an LE Controller":
self.hci.cmd_le_read_buffer_size()
self.address = self.hci.cmd_read_bd_addr()
def start_scan(self):
assert self.is_scannning_enabled is False
self.hci.cmd_le_scan_params()
self.hci.cmd_le_scan_enable(True)
self.is_scannning_enabled = True
def stop_scan(self):
assert self.is_scannning_enabled is True
self.hci.cmd_le_scan_enable(False)
self.is_scannning_enabled = False
def connect(self, address):
return self.connection_mgr.connect(address)
def disconnect(self, connection):
self.connection_mgr.disconnect(connection)
def quit(self):
LOG.debug("BTStack quit()")
self.hci.cmd_reset()
self.hci.kill()
self.cb_thread.kill()
def __init__(self, pyusb_dev=None):
if not pyusb_dev:
pyusb_dev = \
pyusb_bt_sockets.find_first_bt_adapter_pyusb_device_or_raise()
self.hci_socket = pyusb_bt_sockets.PyUSBBluetoothHCISocket(pyusb_dev)
self.hci = HCIThread(self.hci_socket)
self.cb_thread = CallbackThread()
self.cb_thread.register_with_rx_thread(self.hci)
self.is_scannning_enabled = False
self.connection_mgr = ConnectionManager(self.hci, self.cb_thread)
self.address = None
def round_quantity_1(self, asset) -> float:
fee_percent = 0.9995
min_qty, max_qty, step_size = Account.get_lot_size_info(
pair=self.trade_pair)
balance = Account.get_balance(client=ConnectionManager.get_client(),
asset=asset)['free']
trades = ConnectionManager.get_client().get_recent_trades(
symbol=self.trade_pair)
quantity = (float(balance)) * fee_percent
precision = int(round(-math.log(step_size, 10), 0))
return round(quantity, precision)
def start_session(self, asset: str, quote: str):
self.__asset: str = asset
self.__quote_currency: str = quote
self.__trade_pair = str(self.__asset + self.__quote_currency)
self.set_logger(self.__trade_pair)
if config.MODE_WATCH_ONLY:
self.__trade_session = None
else:
balance = float(
Account.get_balance(ConnectionManager.get_client(),
self.__quote_currency)['free'])
self.__trade_session = TradeSession(self.__asset,
self.__quote_currency,
initial_buy=balance)
self.__strategy.on_start(client=ConnectionManager.get_client(),
trade=self.__trade_session)
ConnectionManager.subscribe_to_stream(self.__trade_pair,
on_event_fn=self.handle_event)
def __init__(self, cm=None, client_id=None, prefix="riak",
mapred_prefix="mapred"):
if cm is None:
cm = ConnectionManager.get_http_cm()
self._connections = cm
self._prefix = prefix
self._mapred_prefix = mapred_prefix
self.solr = self.HttpSolrTransport(self)
self.client_id = client_id or self.random_client_id()
def __init__(self, pyusb_dev=None):
if not pyusb_dev:
pyusb_dev = \
pyusb_bt_sockets.find_first_bt_adapter_pyusb_device_or_raise()
self.hci_socket = pyusb_bt_sockets.PyUSBBluetoothHCISocket(pyusb_dev)
self.hci = HCIThread(self.hci_socket)
self.cb_thread = CallbackThread()
self.cb_thread.register_with_rx_thread(self.hci)
self.is_scannning_enabled = False
self.connection_mgr = ConnectionManager(
self.hci, self.cb_thread)
self.address = None
def execute_limit_sell(self, price: float):
print("> Posting Limit Sell Order")
client = ConnectionManager.get_client()
qty = self.round_quantity_1(asset=self.asset)
order = client.order_limit_sell(symbol=self.trade_pair,
quantity=qty,
price="{:.8f}".format(price))
print(order)
print(
"> Limit Sell Posted @ {} (MarketPrice) Executed for '{}'.".format(
price, self.trade_pair))
def __init__(self):
self.__trade_pair = None
self.__trade_session = None
self.__quote_currency = None
self.__asset = None
self.__logger = None
self.__strategy = PCent()
client = ConnectionManager.get_client()
Account.get_balance(client, "BTC")
# Account.get_balance(client, "USDT")
Account.load_trade_pair_info(client)
Account.print_balances()
def connect(self, host, port, bucket, user, pwd, handler):
# Runs open connection on each node and sends control commands
self.lock.acquire()
if self.connection is not None:
raise ConnectedException("Connection already established")
self.rest = RestClient(host, port, user, pwd)
self.rest.update()
cluster_config = self.rest.get_nodes()
bucket_config = self.rest.get_bucket(bucket)
bucket_password = bucket_config['password'].encode('ascii')
self.connection = ConnectionManager(handler)
self.connection.connect(cluster_config, bucket_config)
# Send the sasl auth message
latch = CountdownLatch(len(self.rest.get_nodes()))
op = SaslPlain(bucket, bucket_password, latch)
self.connection.add_operation_all(op)
# Todo: Check the value of get_result
# Send the open connection message
name = 'py_dcp:' + str(uuid.uuid4())[0:7] + str(uuid.uuid4())[0:7]
latch = CountdownLatch(len(self.rest.get_nodes()))
op = OpenConnection(FLAG_OPEN_PRODUCER, name, latch)
self.connection.add_operation_all(op)
# Todo: Check the value of get_result
op.get_result()
# Send the set priority control message
latch = CountdownLatch(len(self.rest.get_nodes()))
op = Control("set_priority", self.priority, latch)
self.connection.add_operation_all(op)
# Todo: Check the value of get_result
# Todo: Add the ability to send control messages
self.lock.release()
def execute_market_sell(self, quantity_percent: float):
print("> Posting Sell Order")
sell_qty = float(self.remaining_quantity * (quantity_percent / 100))
order = ConnectionManager.get_client().order_market_sell(
symbol=self.trade_pair, quantity=sell_qty)
self.exit_prices.append(order['price'])
self.remaining_quantity = float(self.remaining_quantity) - float(
order['executedQty'])
self.my_trades.append(order)
print("> Trade Confirmed : Sell @ {} (MarketPrice) Executed for '{}'.".
format(order['price'], self.trade_pair))
print("> Remaining Quantity: {}".format(self.remaining_quantity))
def __execute_market_buy(self, quote_quantity: float) -> (float, float):
print("> Posting Buy Order")
client = ConnectionManager.get_client()
qty = self.round_quantity()
order = client.order_market_buy(symbol=self.trade_pair, quantity=qty)
print(order)
# avg_entry_price = dict(functools.reduce(operator.add, map(collections.Counter, order['fills'])))['price']
avg_entry_price = order['fills'][0]['price']
qty = order['fills'][0]["qty"]
print("> Trade Confirmed : Buy @ {} (MarketPrice) Executed for '{}'.".
format(order['price'], self.trade_pair))
self.my_trades.append(order)
return float(avg_entry_price), float(qty)
class DcpClient(object):
def __init__(self, priority="medium"):
self.lock = threading.Lock()
self.rest = None
self.connection = None
self.priority = priority
# Returns true is connections are successful
def connect(self, host, port, bucket, user, pwd, handler):
# Runs open connection on each node and sends control commands
self.lock.acquire()
if self.connection is not None:
raise ConnectedException("Connection already established")
self.rest = RestClient(host, port, user, pwd)
self.rest.update()
cluster_config = self.rest.get_nodes()
bucket_config = self.rest.get_bucket(bucket)
bucket_password = bucket_config['password'].encode('ascii')
self.connection = ConnectionManager(handler)
self.connection.connect(cluster_config, bucket_config)
# Send the sasl auth message
latch = CountdownLatch(len(self.rest.get_nodes()))
op = SaslPlain(bucket, bucket_password, latch)
self.connection.add_operation_all(op)
# Todo: Check the value of get_result
# Send the open connection message
name = 'py_dcp:' + str(uuid.uuid4())[0:7] + str(uuid.uuid4())[0:7]
latch = CountdownLatch(len(self.rest.get_nodes()))
op = OpenConnection(FLAG_OPEN_PRODUCER, name, latch)
self.connection.add_operation_all(op)
# Todo: Check the value of get_result
op.get_result()
# Send the set priority control message
latch = CountdownLatch(len(self.rest.get_nodes()))
op = Control("set_priority", self.priority, latch)
self.connection.add_operation_all(op)
# Todo: Check the value of get_result
# Todo: Add the ability to send control messages
self.lock.release()
# Returns true if the stream is successfully created
def add_stream(self, vbucket, flags, start_seqno, end_seqno, vb_uuid,
snap_start, snap_end):
self.lock.acquire()
if self.connection is None:
raise ConnectedException("Not connected")
latch = CountdownLatch()
op = StreamRequest(vbucket, flags, start_seqno, end_seqno, vb_uuid,
snap_start, snap_end, latch)
self.connection.add_operation(op, vbucket)
ret = op.get_result()
self.lock.release()
return ret
# Returns true if the stream is closed successfully
def close_stream(self):
self.lock.acquire()
if self.connection is None:
raise ConnectedException("Not connected")
raise NotImplementedError("Not impemented yet")
self.lock.release()
def close(self):
self.lock.acquire()
self.connection.close()
self.client = None
self.nodes = None
self.buckets = None
self.connection = None
self.lock.release()
def _createConnection(self, info):
connection = ConnectionManager(info)
connection.Connect()
return connection