def price_buy_strategy(): logger = setup_logger("price_buy_strategy") buy_assets = [ BuyAsset(exchange, 'STORJ', 0.00001545, 0.00001400, 0.00002640, 96, 15), BuyAsset(exchange, 'CELR', 0.00000081, 0.00000075, 0.00000174, 96, 15), BuyAsset(exchange, 'ONE', 0.00000102, 0.00000096, 0.00000179, 96, 15), BuyAsset(exchange, 'MATIC', 0.00000101, 0.00000096, 0.00000212, 96, 15), BuyAsset(exchange, 'FTM', 0.00000159, 0.00000149, 0.00000271, 96, 15), BuyAsset(exchange, 'HOT', 0.00000010, 0.00000008, 0.00000026, 96, 15), BuyAsset(exchange, 'DOGE', 0.00000018, 0.00000016, 0.00000046, 96, 15) ] btc_value = get_remaining_btc_binance() adjust_buy_asset_btc_volume(buy_assets, btc_value) check_buy_assets(buy_assets) logger.info("{} -- Starting price_buy_strategy :\n{}".format( exchange, '\n'.join( map( lambda _a: "{}\tbuy : {}\tstop : {}\tprofit : {}".format( _a.name, price_to_string(_a.price), price_to_string(_a.stop_loss_price), price_to_string(_a.price_profit)), buy_assets)))) observe_lower_price_binance(buy_assets) logger.info("price_buy_strategy -- has finished") logger.info("Stop-loss and taking profits in progress only...")
def price_observer_strategy(): logger = setup_logger("price_observer_strategy") buy_assets = [ ObserveAsset('STORJ', 0.00002137, 0.00002080, 0.00004036, 15) ] check_observe_assets(buy_assets) logger.info("Starting price_observer_strategy :\n{}".format( '\n'.join(map(lambda _a: "{}\tbuy : {}\tstop : {}\tprofit : {}".format(_a.name, price_to_string(_a.buy_price), price_to_string(_a.stop_loss_price), price_to_string(_a.price_profit)), buy_assets)))) for buy_asset in buy_assets: ObserverStrategy(buy_asset).run() logger.info("price_observer_strategy -- has finished") logger.info("Stop-loss and taking profits in progress only...")
def price_buy_strategy(): logger = setup_logger("price_buy_strategy") buy_assets = [ BuyAsset(exchange, 'CHR', 0.00000274, 0.00000250, 0.00000294, 96, 15), BuyAsset(exchange, 'VRA', 0.0000000959, 0.0000000939, 0.0000000989, 96, 15), ] btc_value = get_remaining_btc_kucoin() adjust_buy_asset_btc_volume(buy_assets, btc_value) check_buy_assets(buy_assets) logger.info("{} -- Starting price_buy_strategy :\n{}".format(exchange, '\n'.join(map(lambda _a: "{}\tbuy : {}\tstop : {}\tprofit : {}".format(_a.name, price_to_string(_a.price), price_to_string(_a.stop_loss_price), price_to_string(_a.price_profit)), buy_assets)))) observe_lower_price_kucoin(buy_assets) logger.info("price_buy_strategy -- has finished") logger.info("Stop-loss and taking profits in progress only...")
import time from kucoin.client import Client as KucoinClient from library import setup_logger, \ get_format_price, SellAsset, sat exchange = 'kucoin' side = KucoinClient.SIDE_SELL logger = setup_logger("kucoin-hidden-order-{}".format(side)) # currency = 'VIDT' # price = 2640 currency = 'VRA' price = 8.49 stop_loss_price = 2 profit_price = 5700.99 ratio = 1 sell_asset = SellAsset(exchange, currency, stop_loss_price * sat, price=price * sat, ratio=ratio, kucoin_side=side, tight=True) # sell_asset.cancel = False logger.info("Make hidden {} LIMIT order for {}".format(side, sell_asset.market))
from time import sleep, time from bson import CodecOptions from bson.codec_options import TypeRegistry from pymongo.errors import PyMongoError from requests import Session from config import config from library import setup_logger, DecimalCodec, get_time from mongodb import mongo_client from pytesseract import pytesseract import cv2 logger = setup_logger("Crypto-Market-Global-Metrics") cmc_key = config.get_parameter('cmc_key') def get_trading_view_btdc(_count=0): image = cv2.imread('/home/simon/btcd.png') image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) y = 451 x = 188 h = 32 w = 100 crop = image[y:y + h, x:x + w] pytesseract.tesseract_cmd = "tesseract" try: _btcd = float(pytesseract.image_to_string(crop)) except Exception as err:
import time from binance.client import Client as BinanceClient from library import BuyAsset, sat, setup_logger, cancel_binance_current_orders logger = setup_logger("binance-observe-make-order-loop") buy1 = BuyAsset("binance", "TRB", 100 * sat, 29.3 * sat, 44.4 * sat, ticker=BinanceClient.KLINE_INTERVAL_5MINUTE, stop_loss=False) buy2 = BuyAsset("binance", "CHR", 100 * sat, 191 * sat, 265 * sat, ticker=BinanceClient.KLINE_INTERVAL_5MINUTE, stop_loss=False) buy3 = BuyAsset("binance", "COTI", 100 * sat, 232 * sat, 298 * sat, ticker=BinanceClient.KLINE_INTERVAL_5MINUTE, stop_loss=False) assets = [buy1, buy2, buy3]
def buy_local_bottom_bullish_test(_klines, _i): global _trigger global _rsi_low global _rsi_low_fresh global _prev_rsi global _last_ma7_gt_ma100 global _big_volume_sold_out global _bearish_trigger global _prev_rsi_high global _slope_condition logger = setup_logger("test") _btc_value = 0.1 _trade_asset = TradeAsset('ALGO') _trade_asset.set_btc_asset_buy_value(_btc_value) # adjust_buy_asset_btc_volume(_trade_asset, _btc_value) _params = [] strategy = BullishStrategy(_trade_asset, _btc_value, _params) _time_interval = get_binance_interval_unit(strategy.asset.ticker) _time_frame_short = 10 _time_frame_middle = 30 _time_frame_rsi = 50 _time_horizon = 60 _time_horizon_long = 360 try: # strategy.asset.price = lowest_ask(strategy.asset.market) if not is_buy_possible(strategy.asset, strategy.btc_value, strategy.params): strategy.asset.running = False logger.info( "{} buy_local_bottom {} : buy not possible, skipping, exiting". format(strategy.asset.market, strategy)) # sys.exit(0) if not is_bullish_setup(strategy.asset): strategy.asset.running = False logger.info( "{} buy_local_bottom {} : NOT bullish setup, skipping, exiting" .format(strategy.asset.market, strategy)) # sys.exit(0) # _klines = get_klines(strategy.asset, _time_interval) _curr_kline = _klines[-1] _closes = get_closes(_klines) _rsi = relative_strength_index(_closes, _prev_rsi.value, 14, strategy.asset) _max_volume = get_max_volume(_klines, _time_horizon) _rsi_curr = _rsi[-1] _ma7 = talib.MA(_closes, timeperiod=7) _time_curr = _curr_kline[0] _open = float(_curr_kline[1]) _close = _closes[-1] _0time = get_time(_time_curr / 1000) if _rsi_curr > 70: _prev_rsi_high = TimeTuple(_rsi_curr, _time_curr) _rsi_low = False _rsi_low_fresh = False _max_volume = get_max_volume(_klines, _time_horizon) # if _rsi_curr < 33.5 and not is_fresh_test(_prev_rsi_high, _time_frame_rsi, _time_curr): if _rsi_curr < 33.5 and not is_fresh(_prev_rsi_high, _time_frame_rsi): _max_volume_long = get_max_volume(_klines, _time_horizon_long) if volume_condition(_klines, _max_volume_long, 0.9) and not_equal_rsi( _rsi_curr, _rsi_low_fresh): _rsi_low = TimeTuple(_rsi_curr, _time_curr) if _rsi_curr < 33.5 and is_fresh(_prev_rsi_high, _time_frame_middle) and not_equal_rsi( _rsi_curr, _rsi_low): if volume_condition(_klines, _max_volume, 0.9): _rsi_low_fresh = TimeTuple(_rsi_curr, _time_curr) if not _rsi_low and _rsi_curr < 31 and not is_fresh(_prev_rsi_high, _time_frame_rsi) \ and volume_condition(_klines, _max_volume, 0.5) and not_equal_rsi(_rsi_curr, _rsi_low_fresh): if not is_rsi_slope_condition( _rsi, 100, 68, len(_rsi) - 45, -1, _window=10): _rsi_low = TimeTuple(_rsi_curr, _time_curr) else: _slope_condition = TimeTuple(True, _time_curr) if not _rsi_low and _rsi_curr < 20 and not_equal_rsi( _rsi_curr, _rsi_low_fresh): _rsi_low = TimeTuple(_rsi_curr, _time_curr) _c1 = _rsi_low and _rsi_curr < 35 and is_fresh(_rsi_low, _time_frame_rsi) and not is_fresh(_rsi_low, 15) and \ _rsi_curr > _rsi_low.value and not is_fresh(_rsi_low_fresh, _time_frame_middle) _c2 = _rsi_low and _rsi_low_fresh and _rsi_curr > _rsi_low_fresh.value and _rsi_curr > _rsi_low.value and \ not is_fresh(_rsi_low_fresh, _time_frame_middle) _rsi_temp = get_one_of_rsi(_rsi_low_fresh, _rsi_low) _c3 = _rsi_temp and _rsi_curr > _rsi_temp.value and not is_fresh(_rsi_temp, _time_horizon) and \ volume_condition(_klines, _max_volume, 0.9) and _rsi_curr < 33.5 if _c1 or _c2 or _c3: _max_volume_short = get_max_volume(_klines, _time_frame_short) # if _rsi_curr > _rsi_low[0] and volume_condition(_klines, _max_volume, 0.3): # RSI HL if volume_condition(_klines, _max_volume_short, 0.3): # RSI HL _trigger = TimeTuple(True, _time_curr) _max_volume_middle = get_max_volume(_klines, 10) if _rsi_low and _close - _ma7[-1] > 0 and _rsi_curr > _rsi_low.value and \ volume_condition(_klines, _max_volume_middle, 1.0): # reversal _trigger = TimeTuple(True, _time_curr) if _rsi_low and _rsi_low.value < 20 and is_fresh(_rsi_low, 15): _trigger = False if _slope_condition.value: _rsi_low = False _rsi_low_fresh = False _trigger = False if not is_fresh_test(_slope_condition, _time_horizon, _time_curr): _slope_condition = TimeTuple(False, _time_curr) if _rsi_low and is_red_candle(_curr_kline): _green_klines = get_green_candles(_klines) _max_volume_long = get_max_volume(_green_klines, _time_horizon) if volume_condition(_klines, _max_volume_long, 2.1): _rsi_low = False # if _trigger: # i2 = 12 # # dump_variables(_prev_rsi_high, _trigger, _rsi_low, _rsi_low_fresh, # TimeTuple(False, 0), TimeTuple(False, 0), TimeTuple(False, 0)) if _close - _ma7[-1] and is_fresh(_trigger, 15) > 0: logger.info("{} Buy Local Bottom triggered : {} ...".format( strategy.asset.market, strategy)) _la = lowest_ask(strategy.asset.market) strategy.asset.buy_price = _la _possible_buying_quantity = get_buying_asset_quantity( strategy.asset, strategy.btc_value) _quantity_to_buy = adjust_quantity(_possible_buying_quantity, strategy.params) if _quantity_to_buy and is_buy_possible( strategy.asset, strategy.btc_value, strategy.params): strategy.asset.trading = True # _order_id = buy_order(strategy.asset, _quantity_to_buy) # adjust_stop_loss_price(strategy.asset) # adjust_price_profit(strategy.asset) # strategy.set_stop_loss() # wait_until_order_filled(strategy.asset.market, _order_id) # sell_limit(strategy.asset.market, strategy.asset.name, strategy.asset.price_profit) # strategy.set_take_profit() logger.info( "{} Bought Local Bottom {} : price : {} value : {} BTC, exiting" .format(strategy.asset.market, strategy, strategy.asset.buy_price, strategy.btc_value)) strategy.asset.running = False # save_to_file(trades_logs_dir, "buy_klines_{}".format(time.time()), _klines) # sys.exit(0) _prev_rsi = TimeTuple(_rsi, _time_curr) # time.sleep(45) except Exception as err: if isinstance(err, requests.exceptions.ConnectionError): logger.error("Connection problem...") else: traceback.print_tb(err.__traceback__) logger.exception(err.__traceback__)
import time import traceback import requests from library import setup_logger, TradeAsset, get_remaining_btc_binance, adjust_buy_asset_btc_volume, start_trading trade_assets = [ TradeAsset('CELR'), TradeAsset('FTM'), TradeAsset('ONE'), TradeAsset('MATIC'), TradeAsset('ALGO') ] logger = setup_logger("trader") while 1: try: _btc = get_remaining_btc_binance() btc_value = 0.0013 if _btc > 0.0013 else _btc adjust_buy_asset_btc_volume(trade_assets, btc_value) for trade_asset in trade_assets: # remove asset from here start_trading(trade_asset, btc_value) time.sleep(40) except Exception as err: if isinstance(err, requests.exceptions.ConnectionError): logger.error("Connection problem...") else: traceback.print_tb(err.__traceback__)
from library import stop_signal, sat, setup_logger, SellAsset, sell_margin_limit_stop_loss, stop_signal_ext name = "DOGE" stop_price_in_satoshi = 17 stop_price = stop_price_in_satoshi * sat stop_loss_volume = 10000000 sell_asset_binance = SellAsset('binance', name, stop_price, tight=True, stop_loss_volume=stop_loss_volume, delta_price=0) logger = setup_logger(f"margin-stop-loss-volume-{sell_asset_binance.name}") logger.info("Starting {} margin stop-loss maker on {}".format( sell_asset_binance.market, sell_asset_binance.exchange)) logger.info("Margin stop price is set up to : {:.8f} BTC".format(stop_price)) while 1: try: stop = stop_signal_ext(sell_asset_binance) if stop: sell_margin_limit_stop_loss(sell_asset_binance) logger.info("Margin Stop-loss LIMIT order has been made, exiting") sys.exit(0) time.sleep(40) except Exception as err: if isinstance(err, requests.exceptions.ConnectionError) or isinstance( err, requests.exceptions.ReadTimeout):
import re import time import urllib.request from library import authorize, send_mail, setup_logger logger = setup_logger("binance-twitter-observer") authorize() url_twitter = 'https://twitter.com/binance' req_twitter = urllib.request.Request(url_twitter) url_blog = 'https://www.binance.com/en/blog/' req_blog = urllib.request.Request(url_blog) pattern_s = re.compile('\\s+') cnt = 0 t1 = 600 cycle = 0 phrase = 'community coin vote round' def get_response(_req): with urllib.request.urlopen(_req) as response: _page_content = response.read() _content = pattern_s.sub(" ", str(_page_content).lower()) return _content while 1: _content_twitter = get_response(req_twitter) _content_blog = get_response(req_blog)
import time from library import BuyAsset, sat, setup_logger, cancel_kucoin_current_orders from binance.client import Client as BinanceClient from kucoin.client import Client as KucoinClient side = KucoinClient.SIDE_BUY logger = setup_logger("kucoin-observe-hidden-order-loop-{}".format(side)) buy1 = BuyAsset("kucoin", "VIDT", 4173 * sat, ratio=100, kucoin_side=side, ticker=BinanceClient.KLINE_INTERVAL_5MINUTE, sleep=180, stop_loss=False) buy2 = BuyAsset("kucoin", "CHR", 243 * sat, ratio=100, kucoin_side=side, ticker=BinanceClient.KLINE_INTERVAL_5MINUTE, sleep=180, stop_loss=False) buy3 = BuyAsset("kucoin", "OCEAN", 2896 * sat, ratio=100, kucoin_side=side, ticker=BinanceClient.KLINE_INTERVAL_5MINUTE,
import time import traceback import requests from library import setup_logger, start_alerts, AlertAsset, authorize trade_assets = [ AlertAsset('CELR'), AlertAsset('FTM'), AlertAsset('ONE'), AlertAsset('MATIC'), AlertAsset('ALGO') ] logger = setup_logger("alerts") authorize() while 1: try: for trade_asset in trade_assets: # remove asset from here start_alerts(trade_asset) time.sleep(40) except Exception as err: if isinstance(err, requests.exceptions.ConnectionError): logger.error("Connection problem...") else: traceback.print_tb(err.__traceback__) logger.exception(err.__traceback__)
arguments = len(sys.argv) - 1 if arguments == 0: print( "You have to specify type of setups: for longer periods (long), and shorter (short)" ) exit(0) type_of_scan = sys.argv[1] tickers = [] if type_of_scan == "long": tickers = [4, 8, 12, 24] elif type_of_scan == "short": tickers = [0.15, 0.30, 1] logger = setup_logger(f"market-setup-finder-{type_of_scan}") logger.info(f"Starting Market-Setup-Finder...{type_of_scan}") tickers_str = ', '.join(map(str, tickers)) logger.info(f"tickers: {tickers_str}") authorize() db = mongo_client.setups decimal_codec = DecimalCodec() type_registry = TypeRegistry([decimal_codec]) codec_options = CodecOptions(type_registry=type_registry) collection = db.get_collection("asset", codec_options=codec_options) manage_verifying_setup(collection) binance_vol_filter = 20.0 kucoin_vol_filter = 2.0
from time import sleep from binance.client import Client as BinanceClient from binance.exceptions import BinanceAPIException from binance.websockets import BinanceSocketManager from bson import CodecOptions from bson.codec_options import TypeRegistry from kucoin.exceptions import KucoinAPIException from pymongo.errors import PyMongoError from library import get_binance_klines, get_binance_interval_unit, setup_logger, get_kucoin_klines, \ get_kucoin_interval_unit, binance_obj, kucoin_client, DecimalCodec, try_get_klines, TradeMsg, get_last_db_record, \ get_time_from_binance_tmstmp from mongodb import mongo_client logger = setup_logger("Kline-Crawl-Manager-BTC-1m") db = mongo_client.klines decimal_codec = DecimalCodec() type_registry = TypeRegistry([decimal_codec]) codec_options = CodecOptions(type_registry=type_registry) trades = {} def to_mongo_binance(_kline): _data = to_mongo(_kline) _data['buy_btc_volume'] = _kline.buy_btc_volume _data['buy_quantity'] = _kline.buy_quantity _data['sell_btc_volume'] = _kline.sell_btc_volume _data['sell_quantity'] = _kline.sell_quantity
import sys from binance.client import Client as BinanceClient from kucoin.client import Client as KucoinClient from library import BuyAsset, sat, setup_logger, watch_orders, \ set_kucoin_buy_orders, adjust_purchase_fund, wait_until_order_is_filled, authorize, send_mail, get_format_price side = KucoinClient.SIDE_BUY logger = setup_logger("binance-observe-and-make-orders-{}".format(side)) authorize() buy1 = BuyAsset("binance", "TRB", 100 * sat, 29.3 * sat, 44.4 * sat, kucoin_side=side, ticker=BinanceClient.KLINE_INTERVAL_5MINUTE, stop_loss=False) buy2 = BuyAsset("binance", "CHR", 100 * sat, 191 * sat, 265 * sat, kucoin_side=side, ticker=BinanceClient.KLINE_INTERVAL_5MINUTE, stop_loss=False) buy3 = BuyAsset("binance", "COTI", 100 * sat,
import sys from binance.client import Client as BinanceClient from kucoin.client import Client as KucoinClient from library import BuyAsset, sat, setup_logger, watch_orders, \ set_kucoin_buy_orders, adjust_purchase_fund, wait_until_order_is_filled, authorize, send_mail, get_format_price side = KucoinClient.SIDE_BUY logger = setup_logger("kucoin-observe-and-make-hidden-orders-{}".format(side)) authorize() buy1 = BuyAsset("kucoin", "OLT", 33.31 * sat, 29.3 * sat, 44.4 * sat, kucoin_side=side, ticker=BinanceClient.KLINE_INTERVAL_5MINUTE, stop_loss=False) buy2 = BuyAsset("kucoin", "CHR", 212 * sat, 191 * sat, 265 * sat, kucoin_side=side, ticker=BinanceClient.KLINE_INTERVAL_5MINUTE, stop_loss=False) buy3 = BuyAsset("kucoin", "COTI", 253 * sat,
import datetime import time import traceback import requests from binance.client import Client as BinanceClient from bson.codec_options import TypeRegistry, CodecOptions from library import analyze_40ma, setup_logger, authorize, DecimalCodec, manage_verifying_setup, send_mail, MailContent, \ Markets, process_entries from mongodb import mongo_client logger = setup_logger(f"40-ma-analysis") logger.info(f"Starting 40-ma-analysis") authorize() db = mongo_client.setups decimal_codec = DecimalCodec() type_registry = TypeRegistry([decimal_codec]) codec_options = CodecOptions(type_registry=type_registry) collection = db.get_collection("40ma", codec_options=codec_options) # manage_verifying_setup(collection) binance_vol_filter = 40.0 kucoin_vol_filter = 2.0 markets_obj = Markets(binance_vol_filter, kucoin_vol_filter) while 1: try: mail_content = MailContent('')
import time import traceback import requests from library import check_price_slope, check_horizontal_price_level, setup_logger, send_mail, \ authorize, get_last_closing_price, price_to_string, get_klines_asset, check_mas, \ create_observe_assets, log_assets logger = setup_logger("binance_pattern_watcher") logger.info("Starting binance pattern watcher" ) authorize() while 1: assets = create_observe_assets() log_assets(assets) mail_content = None found_assets = [] for asset in assets: try: klines = get_klines_asset(asset) horizon = check_horizontal_price_level(asset, asset.horizon, klines) slope = check_price_slope(asset, klines) mas = check_mas(asset, klines) if mas: i = 1 breakout_type = filter(lambda x: x, [("horizon", price_to_string(asset.buy_price), asset.horizon) if horizon else False, ("slope", asset.line.type) if slope else False]) if horizon or slope or mas: closing_price = get_last_closing_price(asset)
klines_b = get_binance_klines("LTCBTC", "1h", '6 hours ago') # # klines = get_klines("BNBBTC", '1h', '6 hours ago') stop_price_in_satoshi = 777999 stop_price = stop_price_in_satoshi * sat acc = get_or_create_kucoin_trade_account('KCS') vra = kucoin_client.get_order_book('VRA-BTC') sell_asset_binance = SellAsset("binance", "LTC", stop_price, True, '1h') sell_asset_kucoin = SellAsset("kucoin", "VIDT", stop_price, True, '1h') logger = setup_logger(sell_asset_kucoin.name) logger.info("Starting {} stop-loss maker on {}".format(sell_asset_kucoin.market, sell_asset_kucoin.exchange)) logger.info("Stop price is set up to : {:.8f} BTC".format(stop_price)) # cancel_kucoin_current_orders("VIDT-BTC") sell_limit_stop_loss(sell_asset_kucoin.market, sell_asset_kucoin) out1 = stop_signal("binance", sell_asset_binance.market, sell_asset_binance.ticker, stop_price, 1) out2 = stop_signal("kucoin", sell_asset_kucoin.market, sell_asset_kucoin.ticker, stop_price, 1) i = 1
from library import setup_logger, analyze_valuable_alts, MailContent, Markets, get_kucoin_interval_unit, send_mail, \ process_valuable_alts, authorize logger = setup_logger("find-valuable-alts") logger.info("Starting Valuable Alts Finder...") authorize() binance_ticker = "1w" kucoin_ticker = "1week" binance_vol_filter = 50.0 kucoin_vol_filter = 20.0 mail_content = MailContent('') markets_obj = Markets(binance_vol_filter, kucoin_vol_filter) market_setups_binance_raw = analyze_valuable_alts("exclude-markets-binance", "binance", binance_ticker, "30 weeks ago", markets_obj) market_setups_kucoin_raw = analyze_valuable_alts( "exclude-markets-kucoin", "kucoin", kucoin_ticker, get_kucoin_interval_unit(kucoin_ticker, 30), markets_obj) market_setups_binance = sorted(market_setups_binance_raw, key=lambda x: x[1], reverse=True) market_setups_kucoin = sorted(market_setups_kucoin_raw, key=lambda x: x[1], reverse=True)
import datetime from time import sleep from bson.codec_options import TypeRegistry, CodecOptions from library import setup_logger, authorize, read_collections_file, flatten, \ get_last_db_record, DecimalCodec, send_mail, extract_collection_name from mongodb import mongo_client logger = setup_logger("candle_crawl_checker") logger.info("Starting candle crawl checker") authorize() db = mongo_client.klines decimal_codec = DecimalCodec() type_registry = TypeRegistry([decimal_codec]) codec_options = CodecOptions(type_registry=type_registry) tickers = ["15m", "30m", "1h", "4h", "8h", "12h", "1d"] while 1: outdated = [] for raw_name in flatten(read_collections_file()): collection_root_name, exchange = extract_collection_name(raw_name) for ticker in tickers: collection_name = f"{collection_root_name}{ticker}" collection = db.get_collection(collection_name, codec_options=codec_options) record = get_last_db_record(collection)
import sys import time import traceback import requests from library import stop_signal, sat, sell_limit_stop_loss, setup_logger, SellAsset, get_binance_interval_unit name = "CRV" stop_price_in_satoshi = 3300 stop_price = stop_price_in_satoshi * sat sell_asset_binance = SellAsset('binance', name, stop_price) logger = setup_logger(sell_asset_binance.name) logger.info("Starting {} stop-loss maker on {}".format( sell_asset_binance.market, sell_asset_binance.exchange)) logger.info("Stop price is set up to : {:.8f} BTC".format(stop_price)) while 1: try: stop = stop_signal(sell_asset_binance.exchange, sell_asset_binance.market, sell_asset_binance.ticker, stop_price, 1) if stop: sell_limit_stop_loss(sell_asset_binance.market, sell_asset_binance) logger.info("Stop-loss LIMIT order has been made, exiting") sys.exit(0) time.sleep(40) except Exception as err: if isinstance(err, requests.exceptions.ConnectionError) or isinstance(
def buy_local_bottom_bearish_test(_klines, _i): global _prev_rsi_high global _trigger global _rsi_low global _rsi_low_fresh global _prev_rsi global _last_ma7_gt_ma100 global _big_volume_sold_out global _bearish_trigger logger = setup_logger("test") _btc_value = 0.1 _trade_asset = TradeAsset('FTM') _trade_asset.set_btc_asset_buy_value(_btc_value) # adjust_buy_asset_btc_volume(_trade_asset, _btc_value) _params = [] strategy = BullishStrategy(_trade_asset, _btc_value, _params) _time_interval = get_binance_interval_unit(strategy.asset.ticker) _time_frame_middle = 30 _time_frame_rsi = 50 _time_horizon = 60 _time_horizon_long = 360 # while 1: try: strategy.asset.price = lowest_ask(strategy.asset.market) # if not is_buy_possible(strategy.asset, strategy.btc_value, strategy.params): # strategy.asset.running = False # logger.info( # "{} buy_local_bottom : buy not possible, skipping, exiting".format(strategy.asset.market)) # _klines = binance_obj.get_klines_currency(strategy.asset.market, strategy.asset.ticker, _time_interval) _curr_kline = _klines[-1] _closes = get_closes(_klines) _rsi = relative_strength_index(_closes, _prev_rsi.value, 14, strategy.asset) _ma7_curr = talib.MA(_closes, timeperiod=7)[-1] _ma100_curr = talib.MA(_closes, timeperiod=100)[-1] _time_curr = float(_curr_kline[0]) _open = float(_curr_kline[1]) _volume_curr = float(_curr_kline[7]) _close = _closes[-1] _0time = get_time(_time_curr / 1000) _rsi_curr = _rsi[-1] if _rsi_curr < 28: ii = 1 if _ma7_curr > _ma100_curr: _last_ma7_gt_ma100 = TimeTuple(_close, _time_curr) if _last_ma7_gt_ma100.value and is_red_candle( _curr_kline ) and _ma100_curr > _ma7_curr > _close and _rsi_curr < 30: _max_volume_long = get_max_volume(_klines, _time_horizon_long) if volume_condition(_klines, _max_volume_long, 1.2): _big_volume_sold_out = TimeTuple(_volume_curr, _time_curr) if _rsi_curr > 70: _prev_rsi_high = TimeTuple(_rsi_curr, _time_curr) _max_volume = get_max_volume(_klines, _time_horizon) # if _rsi_curr < 33.5 and not is_fresh_test(_prev_rsi_high, _time_frame_rsi, _time_curr): if _rsi_curr < 33.5 and not is_fresh_test(_prev_rsi_high, _time_frame_rsi, _time_curr): _max_volume_long = get_max_volume(_klines, _time_horizon_long) if volume_condition(_klines, _max_volume_long, 0.9) and not_equal_rsi( _rsi_curr, _rsi_low_fresh): _rsi_low = TimeTuple(_rsi_curr, _time_curr) if _rsi_curr < 33.5 and is_fresh_test( _prev_rsi_high, _time_frame_middle, _time_curr) and not_equal_rsi(_rsi_curr, _rsi_low): if volume_condition(_klines, _max_volume, 0.9): _rsi_low_fresh = TimeTuple(_rsi_curr, _time_curr) if not _rsi_low and _rsi_curr < 31 and not is_fresh_test(_prev_rsi_high, _time_frame_rsi, _time_curr) \ and volume_condition(_klines, _max_volume, 0.5) and not_equal_rsi(_rsi_curr, _rsi_low_fresh): _rsi_low = TimeTuple(_rsi_curr, _time_curr) if not _rsi_low and _rsi_curr < 20 and not_equal_rsi( _rsi_curr, _rsi_low_fresh): _rsi_low = TimeTuple(_rsi_curr, _time_curr) _c1 = _rsi_low and _rsi_curr < 33.5 and is_fresh_test(_rsi_low, _time_frame_rsi, _time_curr) and not is_fresh_test(_rsi_low, 15, _time_curr) and \ _rsi_curr > _rsi_low.value and not is_fresh_test(_rsi_low_fresh, _time_frame_middle, _time_curr) _c2 = _rsi_low and _rsi_low_fresh and _rsi_curr > _rsi_low_fresh.value and _rsi_curr > _rsi_low.value and not is_fresh_test( _rsi_low_fresh, _time_frame_middle, _time_curr) _rsi_temp = get_one_of_rsi(_rsi_low_fresh, _rsi_low) _c3 = _rsi_temp and _rsi_curr > _rsi_temp.value and not is_fresh_test( _rsi_temp, _time_horizon, _time_curr) and volume_condition( _klines, _max_volume, 0.9) and _rsi_curr < 33.5 if _c1 or _c2 or _c3: _max_volume_short = get_max_volume(_klines, 10) # if _rsi_curr > _rsi_low[0] and volume_condition(_klines, _max_volume, 0.3): # RSI HL if volume_condition(_klines, _max_volume_short, 0.3): # RSI HL _trigger = TimeTuple(True, _time_curr) _max_volume_middle = get_max_volume(_klines, 15) if _rsi_low and _close - _ma7_curr > 0 and _rsi_curr > _rsi_low.value and volume_condition( _klines, _max_volume_middle, 1.0): # reversal _trigger = TimeTuple(True, _time_curr) if _big_volume_sold_out.value: if price_drop(_last_ma7_gt_ma100.value, _close, 0.08): _bearish_trigger = TimeTuple(True, _time_curr) if _rsi_low and _rsi_low.value < 20 and is_fresh_test( _rsi_low, _time_frame_middle, _time_curr): _trigger = False if _trigger: i2 = 12 if _trigger and _close - _ma7_curr > 0 and is_fresh_test( _bearish_trigger, _time_frame_middle, _time_curr): logger.info("{} Buy Local Bottom triggered...".format( strategy.asset.market)) _la = lowest_ask(strategy.asset.market) strategy.asset.buy_price = _la _possible_buying_quantity = get_buying_asset_quantity( strategy.asset, strategy.btc_value) _quantity_to_buy = adjust_quantity(_possible_buying_quantity, strategy.params) if _quantity_to_buy and is_buy_possible( strategy.asset, strategy.btc_value, strategy.params): strategy.asset.trading = True # _order_id = buy_order(strategy.asset, _quantity_to_buy) adjust_stop_loss_price(strategy.asset) adjust_price_profit(strategy.asset) strategy.set_stop_loss() # wait_until_order_filled(strategy.asset.market, _order_id) # sell_limit(strategy.asset.market, strategy.asset.name, strategy.asset.price_profit) strategy.set_take_profit() logger.info( "{} Bought Local Bottom : price : {} value : {} BTC, exiting" .format(strategy.asset.market, strategy.asset.buy_price, strategy.btc_value)) strategy.asset.running = False # save_to_file(trades_logs_dir, "buy_klines_{}".format(time.time()), _klines) _prev_rsi = TimeTuple(_rsi_curr, _time_curr) # time.sleep(1) except Exception as err: if isinstance(err, requests.exceptions.ConnectionError): logger.error("Connection problem...") else: traceback.print_tb(err.__traceback__) logger.exception(err.__traceback__)
import datetime import json import sys import urllib from time import sleep from bson import CodecOptions from bson.codec_options import TypeRegistry from requests import Session from config import config from library import setup_logger, DecimalCodec, authorize, send_mail from mongodb import mongo_client logger = setup_logger("BTC-Dominance-Watcher") cmc_key = config.get_parameter('cmc_key') url = 'https://pro-api.coinmarketcap.com/v1/global-metrics/quotes/latest' parameters = {'start': '1', 'limit': '5000', 'convert': 'USD'} headers = { 'Accepts': 'application/json', 'X-CMC_PRO_API_KEY': cmc_key, } session = Session() session.headers.update(headers) db = mongo_client.market_data decimal_codec = DecimalCodec() type_registry = TypeRegistry([decimal_codec]) codec_options = CodecOptions(type_registry=type_registry)
from time import sleep from binance.client import Client as BinanceClient from binance.exceptions import BinanceAPIException from binance.websockets import BinanceSocketManager from bson import CodecOptions from bson.codec_options import TypeRegistry from kucoin.exceptions import KucoinAPIException from pymongo.errors import PyMongoError from library import get_binance_klines, get_binance_interval_unit, setup_logger, binance_obj, kucoin_client, \ DecimalCodec, try_get_klines, TradeMsg, get_last_db_record, \ get_time_from_binance_tmstmp, from_binance_socket_kline from mongodb import mongo_client logger = setup_logger("Kline-Crawl-Manager-LTF") db = mongo_client.klines decimal_codec = DecimalCodec() type_registry = TypeRegistry([decimal_codec]) codec_options = CodecOptions(type_registry=type_registry) trades = {} klines_socket = {} def to_mongo_binance(_kline): _data = to_mongo(_kline) _data['buy_btc_volume'] = _kline.buy_btc_volume _data['buy_quantity'] = _kline.buy_quantity _data['sell_btc_volume'] = _kline.sell_btc_volume
import datetime import time import traceback import requests from bson.codec_options import TypeRegistry, CodecOptions from library import setup_logger, get_kucoin_interval_unit, process_setups, \ DecimalCodec, manage_verifying_setup, MailContent, analyze_micro_markets, Markets from mongodb import mongo_client logger = setup_logger("market-micro-setup-finder") logger.info("Starting Market-Micro-Setup-Finder...") # authorize() db = mongo_client.micro decimal_codec = DecimalCodec() type_registry = TypeRegistry([decimal_codec]) codec_options = CodecOptions(type_registry=type_registry) collection = db.get_collection("asset", codec_options=codec_options) manage_verifying_setup(collection) binance_vol_filter = 50.0 kucoin_vol_filter = 20.0 markets_obj = Markets(binance_vol_filter, kucoin_vol_filter) while 1: try: _tickers = [0.5]