def __init__(self, brg: Bargain, cond, logger=None):
"""
Initialise cond_frame et des hookedSrcID to exclude from evaluation.
- brg: Une prise we
- cond: un tuple (type, 'op', value).
Si type is usualy temps (then val is Timestamp) ou prix (val float)
"""
self.brg = brg
self.logger = get_logger(logger, sLL="INFO", name=__name__)
# Une liste de mots clef pour le prix
# Fairprice = market price et lastPrice ~= midPrice
self.price_list = [
"lastPrice",
"indexPrice",
"bidPrice",
"askPrice",
"markPrice",
"IndexPrice",
"LastPrice",
"MarkPrice",
"lastMidPrice",
]
# to cached hooked ID, il ne doit y en avoir qu'un
self.hookedSrcID = ""
self.excludeIDs: Set[str] = set()
# store les conditions dans un df avec les cols (genre, op, value)
self.cond_frame = self.forme_conditions(cond)
def main_prg():
"""Load arguments and run main program."""
cmdArgs = get_cmd_args()
defaultArgs = argsO()
logger = get_logger(
logger=rlogger,
name=LOGNAME,
sLL=cmdArgs.logLevel,
logFile=defaultArgs.logFile,
fmt_=LOGFMT,
)
dbo = DummyBitMEX(up=0, logger=logger) if cmdArgs.dummy else None
tma = MarketAuditeur(live=cmdArgs.liveRun,
dbo=dbo,
logger=logger,
symbol=cmdArgs.symbol)
tma.start_server()
try:
go_multi(
tma,
arg_file=cmdArgs.morders,
logpause=defaultArgs.logPause,
updatepause=defaultArgs.updatePause,
)
except ke.wsException:
rlogger.exception("Erreur dans la socket... Quelque chose se prépare.")
def __init__(self, apiKey, apiSecret, logger=None, symbol=None):
self.__reset()
self.apiKey = apiKey
self.apiSecret = apiSecret
self.logger = get_logger(logger, name=__name__, sLL="INFO")
self.retries = 1
# not goog practice as it will be only for one symbol can't do ...arbitrage
self.wsURL = None # will contain the wsURL after first connection
self.symbol = symbol
self.logger.debug(f"Init {self}")
def main_prg():
"""Parse argument and run main program."""
args = get_args()
rlogger = setup_logging()
rlogger = get_logger(name=__name__, sLL='DEBUG', fmt_=LOGFMT)
run(logger_=rlogger,
func_=args.func,
live_=args.liveRun,
symbol_=args.Symbol)
sys.exit()
def main_prg():
"""Parse args and run main program."""
args = get_args()
kwargs = {
"tps_run": args.tps_run,
"prix": args.prix,
"essais": args.nbEssais,
"side": args.side,
"q": args.quantity,
"tp": args.tailPrice,
"atype": args.aType,
"oType": args.oType,
"updatepause": args.updatePause,
"logpause": args.logPause,
"dr_pause": args.drPause,
"tType": args.tType,
"timeOut": args.tOut,
"sDelta": args.sDelta,
"arg_file": args.argFile,
"name": args.name,
"hook": args.Hook,
}
rlogger = setup_logging()
rlogger = get_logger(name=LOGNAME,
sLL=args.logLevel,
logFile=args.logFile,
fmt_=LOGFMT)
dbo = DummyBitMEX(up=0, logger=rlogger) if args.dummy else None
tma = MarketAuditeur(live=args.liveRun,
dbo=dbo,
logger=rlogger,
symbol=args.symbol)
tma.start_server()
try:
if args.argFile is None:
# on démarre un truc simple
_ = kwargs.pop("arg_file")
t = threading.Thread(target=tma.go, name=args.name, kwargs=kwargs)
t.start()
else:
go_multi(
tma,
arg_file=args.argFile,
logpause=args.logPause,
updatepause=args.updatePause,
)
except ke.wsException:
rlogger.exception("Erreur dans la socket... Quelque chose se prépare.")
def __init__(
self,
base_url=None,
symbol=None,
apiKey=None,
apiSecret=None,
orderIDPrefix=ORDERID_PREFIX,
shouldWSAuth=True,
postOnly=False,
timeout=8,
logger=None,
):
"""Init connector."""
self.dummy = False # to flag this as not dummy
self.logger = get_logger(logger, name=__name__, sLL="DEBUG")
self.base_url = base_url
self.symbol = symbol
self.prec = PRICE_PRECISION[symbol]
self.postOnly = postOnly
if apiKey is None:
raise Exception("Please set an API key and Secret.")
self.apiKey = apiKey
self.apiSecret = apiSecret
if len(orderIDPrefix) > 13:
raise ValueError(
"settings.ORDERID_PREFIX must be at most 13 characters long!")
self.orderIDPrefix = orderIDPrefix
self.retries = 0 # initialize counter
# Prepare HTTPS session
self.session = rq.Session()
# These headers are always sent
self.session.headers.update(
{"user-agent":
"idev-"}) # peut tester avec un autre nom (liquidbot)
self.session.headers.update({"content-type": "application/json"})
self.session.headers.update({"accept": "application/json"})
# Create websocket for streaming data
ws = BitMEXWebsocket(self.apiKey,
self.apiSecret,
logger=self.logger,
symbol=symbol)
self.ws = ws
self.logger.debug(f"ws={ws}")
self.ws.connect(base_url, symbol, shouldAuth=shouldWSAuth)
self.timeout = timeout
self.logger.info(f"Fini init {self}")
def __init__(
self,
hSrc,
hStatus,
send_queue,
order,
cond,
valid_queue,
nameT,
timeout,
logger=None,
excludeIDs_=None,
symbol="XBTUSD",
):
"""
Init a Hook ordre object.
It's an OrderConditionned with an additionnal hooked condition.
- hSrc : abbrevattion used to identify the clOrdID.
- hStatus : the hook OrdType that the clOrdID must satisfy.
"""
# Save the clOrdID of the src order to which this whas hooked
self.hSrc = hSrc
self.hStatus = hStatus
self.is_hooked: bool = False
self.excludeIDs = excludeIDs_
self.symbol = symbol
# for the symbol need some change to hook on other symbols
OrderConditionned.__init__(
self,
send_queue=send_queue,
order=order,
cond=cond,
valid_queue=valid_queue,
logger=logger,
nameT=nameT,
timeout=timeout,
symbol=symbol,
)
self.init_cond_frame = self.condition.cond_frame.copy()
self.relative_values = {}
self.logger = get_logger(logger, sLL="INFO", name=__name__)
def __init__(self,
start_price=7900,
up=0.1,
data=None,
logger=None,
N=1000):
self.logger = get_logger(logger=logger, name=__name__, sLL="INFO")
self.dummy = True
self.startPrice = start_price
self.up = up
self.N = N
self.pg = PriceGen(startPrice=start_price, N=N, up=up, data=data)
self.next_datum = self.pg.next # creat a new price
self.current_dum_price = self.next_datum()
self.availableMargin = 1e7
self.dummyID = "dummyIDDIDIDIDI"
self.symbol = "XBTUSD"
self.prec = PRICE_PRECISION["XBTUSD"]
def __init__(self,
brg,
recpt_queue,
valid_queue=None,
logger=None,
nameT="chrsT"):
"""Un thread qui tourne jsuqu'à ce que stop soit vrai.
utilise brg pour passer les orders reçu dans la queue.
vérifie la queue chaque freq secondes"""
threading.Thread.__init__(self, name=nameT)
self.brg = brg
self.recpt_queue = recpt_queue
self.valid_queue = valid_queue
self.reply_queue: Queue = Queue()
self.stop = False
self.logger = get_logger(logger, name=__name__, sLL="INFO")
self.logger.info(f"Fini init {self}")
def __init__(self,
live: bool = False,
dbo=None,
logger=None,
symbol=SYMBOL):
"""
Une classe pour placer un ordre conditionné et sa trace sur bitmex.
Place an order pair on symbol market.
Un auditeur de marché, c'est une connexion qui écoute les prix du marché
- serveur chronos: envoie les ordres au marché
- ordre principal d'achat ou de vente conditionné par le temps ou le prix
- ordre de trace conditionné par le prix et qui sert aussi de stop loss.
"""
self.live: bool = live # connexion à live bitmex or test.bitmex
self.ocp: Optional[Union[OrderConditionned,
HookOrder]] = None # ordre principal
self.stop: Optional[bool] = False
self.symbol = symbol
self.dbo = dbo # dummy bitmex for test
# on garde un suivi de la balance ici pour further analysis
self.resultats = pd.DataFrame(
index=pd.DatetimeIndex(data=[], name="start_time"),
columns=["balance", "benef"],
)
daynum = pd.Timestamp.now().strftime("%j")
prefix = "tma" + daynum if live else "fma" + daynum
prefix += "-dum" if self.dbo is not None else ""
logfile = "./Logs/multi_kola.org"
if logger:
self.logger = logger
else:
self.logger = get_logger(logger,
name=__name__,
sLL="INFO",
logFile=logfile)
# to cache the hooks
self.hookedIDs: Set[str] = set()
self.logger.info(f"Market Auditeur Initialisé: {self}")
def __init__(
self,
postOnly=POST_ONLY,
live=False,
symbol=SYMBOL,
orderIDPrefix=ORDERID_PREFIX,
timeout=TIMEOUT,
logger=None,
dbo=None,
):
"""Initialisation dbo is a dummy bitMEX object used for testing."""
self.logger = get_logger(logger, name=__name__, sLL="INFO")
self.symbol = symbol
self.precision = PRICE_PRECISION[symbol]
self.last_check_time = now() - Timedelta(
2, unit="D") # on s'assure d'être dans le passé.
self.cached_refPrices = None
self.live = live
if self.live and dbo is None:
baseUrl, apiKey, apiSecret = LIVE_URL, LIVE_KEY, LIVE_SECRET
else:
baseUrl, apiKey, apiSecret = TEST_URL, TEST_KEY, TEST_SECRET
if dbo:
self.bto = dbo
self.dbo = dbo
else:
# si on ne passe pas l'argument dummy BitMEX object
# On en crée un réel
self.bto = BitMEX(
base_url=baseUrl,
symbol=self.symbol,
apiKey=apiKey,
apiSecret=apiSecret,
orderIDPrefix=orderIDPrefix,
postOnly=postOnly,
timeout=timeout,
logger=self.logger,
)
self.dbo = None
self.logger.info(f"Fini init {self}")
def __init__(
self,
send_queue,
order,
cond,
valid_queue=None,
logger=None,
nameT=None,
timeout=None,
symbol="XBTUSD",
):
"""
Une queue, pour passer les ordres, un ordre à passer si la condition est validée.
- l'ordre (order) peut être stopé prématurement en mettant stop=True
- order est un dict avec keys: side, orderQty..
- un timeout pendant lequel l'ordre (dont l'évaluation de sa condition) est actif
def 2 jours
- hook : nom du hook, ou de l'abbrevation qui sert de hook.
- sLL= debug level
-symbol: symbol for this order, def. XBTUSD
"""
Thread.__init__(self, name=nameT)
self.logger = get_logger(logger, sLL="INFO", name=__name__)
self.symbol = symbol
self.send_queue = send_queue
self.valid_queue = valid_queue
self.condition = cond
self.stop = False
self.orderIDPrefix = "mlk_"
self.order = order # a dict ex. {'side': 'buy', 'orderQty': 100, 'options'...}
self.oclid = newClID(abbv_=nameT)
self.order["clOrdID"] = self.oclid
# default for timeOut (2 days)
# could add a timecond eg cVraieTpsDiffA(timeOut.seconds or delta)
self.timeOut = setdef_timedelta(timeout, pd.Timedelta(2, unit="D"))
self.startTime = now()
def __init__(
self,
price,
refPrice,
tail_perct_init=0.5,
head="buy",
updatepause=6,
timeBin=60,
logger=None,
max_var=2.6,
min_flex=0.2,
symbol="XBTUSD",
):
"""
Head is the direction, need a price (market price and ref price) and
tail_perct_init (%): default. Le nb_enregistrement est la longeur
de la bd des prix
- Une tête sur la prix du marché référence et trois queues
(tails ou tails).
- La queue bleu (Qbleue) elle suit le prix du marché toujours à la même
distance (même épaisseur)
- La queue rouge, c'est le stop, elle ne bouge pas tant qu'il n'y a pas
de bénéf.
- La queue verte (flexTail) elle est d'épaisseur variable,
son prix est passé au brokeur si au dessus du refPrice
- min_flex est le pourcentage de la refTail jusqu'ou
on peux réduire la flexTail ex. 80 de la ref tail
- main_window_size c'est la taille de l'historique de ce prixObject,
doit être calcule en fonction de la taille de la bin voulue
et de la fréquence des mis à jour
- updatepause c'est le nombre moyen de secondes entre deux mise à jour
- timeBin c'est la taille de la fenêtre utilisé pour calculer
la variation de prix.
avec la updatepause permet d'estimer la main_window_size
- max_var en quoi? et min_flex determine la flexibilité des queue.
max_var est une statistique décrivant la variation nécessaire
pour que la queue se réduise à min_flex. Elle est issue d'obeservation
du marché voir getting_data.ipyng. la var à un très long mais fine queue.
90% < .22
- symbol: keep track of price symbol to format and round price correctly
"""
self.logger = get_logger(logger, sLL="INFO", name=__name__)
self.head = head
self.refPrice = refPrice
self.symbol = symbol
self.prec = PRICE_PRECISION[symbol]
self.tail_perct_init = tail_perct_init # tail percent sera appliqué au prix de référence nombre entre 0 et 100
self.timeBin = timeBin
self.updatePause = updatepause
# essaye d'avoir un tableau plus grand que nécessaire
# par défaut ~30
self.main_window_size = int(timeBin / self.updatePause * 4)
# on défini une fonction pour mettre à jour la flexTail
# le maxiumn de variation jamais observé pour la bin en pourcentage de variation
# TODO: mieux définir cette fonction...
self.max_var = max_var
N = 100
self.neg_exps = self.__neg_exps(self.max_var, N)
self.var_dist_hist = pd.Series(index=range(N), data=self.neg_exps)
self.min_flex = min_flex
# on initialise les prix et la df qui les contiendra
# define self.data
self.data = None
self.data = self.__init_price_df(price, refPrice)
# on définie l'épaisseur du stop
self.tail_base_width = round_sprice(
abs(self.data.refPrice.init - self.data.refTail.init), symbol)
# -*- coding: utf-8 -*-
import argparse
import numpy as np
import re
from kolaBitMEXBot.kola.utils.logfunc import get_logger
from kolaBitMEXBot.kola.settings import LOGNAME
from kolaBitMEXBot.kola.utils.pricefunc import get_prices, get_prix_decl
from kolaBitMEXBot.kola.utils.orderfunc import (
set_order_type,
set_exec_instructions,
set_price_type,
is_valid_order_options,
)
mlogger = get_logger(name=f"{LOGNAME}.{__name__}")
def get_args():
"""
Parse the function's arguments
"""
description = """
Un bot pour faire du trading de cryptomonnaie.
"""
# default
name_def = "NaDef"
aType_def = "p%%q%%t%%"
argFile_def = None
dr_pause_def = None