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]
