[perso/Immae/Projets/Cryptomonnaies/Cryptoportfolio/Trader.git] / helper.py

from datetime import datetime
import argparse
import configparser
import psycopg2
import os
import sys

import portfolio

def make_order(market, value, currency, action="acquire",
        close_if_possible=False, base_currency="BTC", follow=True,
        compute_value="average"):
    """
    Make an order on market
    "market": The market on which to place the order
    "value": The value in *base_currency* to acquire,
             or in *currency* to dispose.
             use negative for margin trade.
    "action": "acquire" or "dispose".
                "acquire" will buy long or sell short,
                "dispose" will sell long or buy short.
    "currency": The currency to acquire or dispose
    "base_currency": The base currency. The value is expressed in that
                     currency (default: BTC)
    "follow": Whether to follow the order once run (default: True)
    "close_if_possible": Whether to try to close the position at the end
                         of the trade, i.e. reach exactly 0 at the end
                         (only meaningful in "dispose"). May have
                         unwanted effects if the end value of the
                         currency is not 0.
    "compute_value": Compute value to place the order
    """
    market.report.log_stage("make_order_begin")
    market.balances.fetch_balances(tag="make_order_begin")
    if action == "acquire":
        trade = portfolio.Trade(
                portfolio.Amount(base_currency, 0),
                portfolio.Amount(base_currency, value),
                currency, market)
    else:
        amount = portfolio.Amount(currency, value)
        trade = portfolio.Trade(
                amount.in_currency(base_currency, market, compute_value=compute_value),
                portfolio.Amount(base_currency, 0),
                currency, market)
    market.trades.all.append(trade)
    order = trade.prepare_order(
            close_if_possible=close_if_possible,
            compute_value=compute_value)
    market.report.log_orders([order], None, compute_value)
    market.trades.run_orders()
    if follow:
        market.follow_orders()
        market.balances.fetch_balances(tag="make_order_end")
    else:
        market.report.log_stage("make_order_end_not_followed")
        return order
    market.report.log_stage("make_order_end")

def get_user_market(config_path, user_id, debug=False):
    import market
    pg_config, report_path = main_parse_config(config_path)
    market_config = list(main_fetch_markets(pg_config, str(user_id)))[0][0]
    return market.Market.from_config(market_config, debug=debug)

def main_parse_args(argv):
    parser = argparse.ArgumentParser(
            description="Run the trade bot")

    parser.add_argument("-c", "--config",
            default="config.ini",
            required=False,
            help="Config file to load (default: config.ini)")
    parser.add_argument("--before",
            default=False, action='store_const', const=True,
            help="Run the steps before the cryptoportfolio update")
    parser.add_argument("--after",
            default=False, action='store_const', const=True,
            help="Run the steps after the cryptoportfolio update")
    parser.add_argument("--debug",
            default=False, action='store_const', const=True,
            help="Run in debug mode")
    parser.add_argument("--user",
            default=None, required=False, help="Only run for that user")
    parser.add_argument("--action",
            action='append',
            help="Do a different action than trading (add several times to chain)")

    args = parser.parse_args(argv)

    if not os.path.exists(args.config):
        print("no config file found, exiting")
        sys.exit(1)

    return args

def main_parse_config(config_file):
    config = configparser.ConfigParser()
    config.read(config_file)

    if "postgresql" not in config:
        print("no configuration for postgresql in config file")
        sys.exit(1)

    if "app" in config and "report_path" in config["app"]:
        report_path = config["app"]["report_path"]

        if not os.path.exists(report_path):
            os.makedirs(report_path)
    else:
        report_path = None

    return [config["postgresql"], report_path]

def main_fetch_markets(pg_config, user):
    connection = psycopg2.connect(**pg_config)
    cursor = connection.cursor()

    if user is None:
        cursor.execute("SELECT config,user_id FROM market_configs")
    else:
        cursor.execute("SELECT config,user_id FROM market_configs WHERE user_id = %s", user)

    for row in cursor:
        yield row

def main_process_market(user_market, actions, before=False, after=False):
    if len(actions or []) == 0:
        if before:
            Processor(user_market).process("sell_all", steps="before")
        if after:
            Processor(user_market).process("sell_all", steps="after")
    else:
        for action in actions:
            if action in globals():
                (globals()[action])(user_market)
            else:
                raise NotImplementedError("Unknown action {}".format(action))

def main_store_report(report_path, user_id, user_market):
    try:
        if report_path is not None:
            report_file = "{}/{}_{}.json".format(report_path, datetime.now().isoformat(), user_id)
            with open(report_file, "w") as f:
                f.write(user_market.report.to_json())
    except Exception as e:
        print("impossible to store report file: {}; {}".format(e.__class__.__name__, e))

def print_orders(market, base_currency="BTC"):
    market.report.log_stage("print_orders")
    market.balances.fetch_balances(tag="print_orders")
    market.prepare_trades(base_currency=base_currency, compute_value="average")
    market.trades.prepare_orders(compute_value="average")

def print_balances(market, base_currency="BTC"):
    market.report.log_stage("print_balances")
    market.balances.fetch_balances()
    if base_currency is not None:
        market.report.print_log("total:")
        market.report.print_log(sum(market.balances.in_currency(base_currency).values()))

class Processor:
    scenarios = {
            "sell_needed": [
                {
                    "name": "wait",
                    "number": 0,
                    "before": False,
                    "after": True,
                    "wait_for_recent": {},
                    },
                {
                    "name": "sell",
                    "number": 1,
                    "before": False,
                    "after": True,
                    "fetch_balances": ["begin", "end"],
                    "prepare_trades": {},
                    "prepare_orders": { "only": "dispose", "compute_value": "average" },
                    "run_orders": {},
                    "follow_orders": {},
                    },
                {
                    "name": "buy",
                    "number": 2,
                    "before": False,
                    "after": True,
                    "fetch_balances": ["begin", "end"],
                    "prepare_trades": { "only": "acquire" },
                    "prepare_orders": { "only": "acquire", "compute_value": "average" },
                    "move_balances": {},
                    "run_orders": {},
                    "follow_orders": {},
                    },
                ],
            "sell_all": [
                {
                    "name": "all_sell",
                    "number": 1,
                    "before": True,
                    "after": False,
                    "fetch_balances": ["begin", "end"],
                    "prepare_trades": { "repartition": { "BTC": (1, "long") } },
                    "prepare_orders": { "compute_value": "average" },
                    "run_orders": {},
                    "follow_orders": {},
                    },
                {
                    "name": "wait",
                    "number": 2,
                    "before": False,
                    "after": True,
                    "wait_for_recent": {},
                    },
                {
                    "name": "all_buy",
                    "number": 3,
                    "before": False,
                    "after": True,
                    "fetch_balances": ["begin", "end"],
                    "prepare_trades": {},
                    "prepare_orders": { "compute_value": "average" },
                    "move_balances": {},
                    "run_orders": {},
                    "follow_orders": {},
                    },
                ]
            }

    allowed_arguments = {
            "wait_for_recent": ["delta"],
            "prepare_trades": ["base_currency", "liquidity", "compute_value", "repartition", "only"],
            "prepare_orders": ["only", "compute_value"],
            "move_balances": [],
            "run_orders": [],
            "follow_orders": ["sleep"],
            }

    def __init__(self, market):
        self.market = market

    def select_steps(self, scenario, step):
        if step == "all":
            return scenario
        elif step == "before" or step == "after":
            return list(filter(lambda x: step in x and x[step], scenario))
        elif type(step) == int:
            return [scenario[step-1]]
        elif type(step) == str:
            return list(filter(lambda x: x["name"] == step, scenario))
        else:
            raise TypeError("Unknown step {}".format(step))

    def process(self, scenario_name, steps="all", **kwargs):
        scenario = self.scenarios[scenario_name]
        selected_steps = []

        if type(steps) == str or type(steps) == int:
            selected_steps += self.select_steps(scenario, steps)
        else:
            for step in steps:
                selected_steps += self.select_steps(scenario, step)
        for step in selected_steps:
            self.process_step(scenario_name, step, **kwargs)

    def process_step(self, scenario_name, step, **kwargs):
        process_name = "process_{}__{}_{}".format(scenario_name, step["number"], step["name"])
        self.market.report.log_stage("{}_begin".format(process_name))
        if "begin" in step.get("fetch_balances", []):
            self.market.balances.fetch_balances(tag="{}_begin".format(process_name))

        for action in ["wait_for_recent", "prepare_trades",
                "prepare_orders", "move_balances", "run_orders",
                "follow_orders"]:
            if action in step:
                self.run_action(action, step[action], **kwargs)

        if "end" in step.get("fetch_balances", []):
            self.market.balances.fetch_balances(tag="{}_end".format(process_name))
        self.market.report.log_stage("{}_end".format(process_name))

    def run_action(self, action, default_args, **kwargs):
        args = {k: v for k, v in {**default_args, **kwargs}.items() if k in self.allowed_arguments[action] }

        if action == "wait_for_recent":
            portfolio.Portfolio.wait_for_recent(self.market, **args)
        if action == "prepare_trades":
            self.market.prepare_trades(**args)
        if action == "prepare_orders":
            self.market.trades.prepare_orders(**args)
        if action == "move_balances":
            self.market.move_balances(**args)
        if action == "run_orders":
            self.market.trades.run_orders(**args)
        if action == "follow_orders":
            self.market.follow_orders(**args)

def process_sell_needed__1_sell(market, liquidity="medium", base_currency="BTC"):
    Processor(market).process("sell_needed", steps="sell",
            liquidity=liquidity, base_currency=base_currency)

def process_sell_needed__2_buy(market, liquidity="medium", base_currency="BTC"):
    Processor(market).process("sell_needed", steps="buy",
            liquidity=liquidity, base_currency=base_currency)

def process_sell_all__1_all_sell(market, base_currency="BTC", liquidity="medium"):
    Processor(market).process("sell_all", steps="all_sell",
            liquidity=liquidity, base_currency=base_currency)

def process_sell_all__2_wait(market, liquidity="medium", base_currency="BTC"):
    Processor(market).process("sell_all", steps="wait",
            liquidity=liquidity, base_currency=base_currency)

def process_sell_all__3_all_buy(market, base_currency="BTC", liquidity="medium"):
    Processor(market).process("sell_all", steps="all_buy",
            liquidity=liquidity, base_currency=base_currency)
Commit	Line	Data
f86ee140 IB	1	from datetime import datetime
	2	import argparse
	3	import configparser
	4	import psycopg2
	5	import os
	6	import sys
	7
	8	import portfolio
	9
2033e7fe IB	10	def make_order(market, value, currency, action="acquire",
	11	close_if_possible=False, base_currency="BTC", follow=True,
	12	compute_value="average"):
	13	"""
	14	Make an order on market
	15	"market": The market on which to place the order
	16	"value": The value in base_currency to acquire,
	17	or in currency to dispose.
	18	use negative for margin trade.
	19	"action": "acquire" or "dispose".
	20	"acquire" will buy long or sell short,
	21	"dispose" will sell long or buy short.
	22	"currency": The currency to acquire or dispose
	23	"base_currency": The base currency. The value is expressed in that
	24	currency (default: BTC)
	25	"follow": Whether to follow the order once run (default: True)
	26	"close_if_possible": Whether to try to close the position at the end
	27	of the trade, i.e. reach exactly 0 at the end
	28	(only meaningful in "dispose"). May have
	29	unwanted effects if the end value of the
	30	currency is not 0.
	31	"compute_value": Compute value to place the order
	32	"""
	33	market.report.log_stage("make_order_begin")
	34	market.balances.fetch_balances(tag="make_order_begin")
	35	if action == "acquire":
	36	trade = portfolio.Trade(
	37	portfolio.Amount(base_currency, 0),
	38	portfolio.Amount(base_currency, value),
	39	currency, market)
	40	else:
	41	amount = portfolio.Amount(currency, value)
	42	trade = portfolio.Trade(
	43	amount.in_currency(base_currency, market, compute_value=compute_value),
	44	portfolio.Amount(base_currency, 0),
	45	currency, market)
	46	market.trades.all.append(trade)
	47	order = trade.prepare_order(
	48	close_if_possible=close_if_possible,
	49	compute_value=compute_value)
	50	market.report.log_orders([order], None, compute_value)
	51	market.trades.run_orders()
	52	if follow:
	53	market.follow_orders()
	54	market.balances.fetch_balances(tag="make_order_end")
	55	else:
	56	market.report.log_stage("make_order_end_not_followed")
	57	return order
	58	market.report.log_stage("make_order_end")
	59
	60	def get_user_market(config_path, user_id, debug=False):
	61	import market
	62	pg_config, report_path = main_parse_config(config_path)
	63	market_config = list(main_fetch_markets(pg_config, str(user_id)))[0][0]
	64	return market.Market.from_config(market_config, debug=debug)
	65
f86ee140 IB	66	def main_parse_args(argv):
	67	parser = argparse.ArgumentParser(
	68	description="Run the trade bot")
	69
	70	parser.add_argument("-c", "--config",
	71	default="config.ini",
	72	required=False,
	73	help="Config file to load (default: config.ini)")
	74	parser.add_argument("--before",
	75	default=False, action='store_const', const=True,
	76	help="Run the steps before the cryptoportfolio update")
	77	parser.add_argument("--after",
	78	default=False, action='store_const', const=True,
	79	help="Run the steps after the cryptoportfolio update")
	80	parser.add_argument("--debug",
	81	default=False, action='store_const', const=True,
	82	help="Run in debug mode")
516a2517 IB	83	parser.add_argument("--user",
	84	default=None, required=False, help="Only run for that user")
	85	parser.add_argument("--action",
23f4616a IB	86	action='append',
23f4616a IB	87	help="Do a different action than trading (add several times to chain)")
f86ee140 IB	88
	89	args = parser.parse_args(argv)
	90
	91	if not os.path.exists(args.config):
	92	print("no config file found, exiting")
	93	sys.exit(1)
	94
	95	return args
	96
	97	def main_parse_config(config_file):
	98	config = configparser.ConfigParser()
	99	config.read(config_file)
	100
	101	if "postgresql" not in config:
	102	print("no configuration for postgresql in config file")
	103	sys.exit(1)
	104
	105	if "app" in config and "report_path" in config["app"]:
	106	report_path = config["app"]["report_path"]
	107
	108	if not os.path.exists(report_path):
	109	os.makedirs(report_path)
	110	else:
	111	report_path = None
	112
	113	return [config["postgresql"], report_path]
	114
516a2517	115	def main_fetch_markets(pg_config, user):
f86ee140 IB	116	connection = psycopg2.connect(**pg_config)
	117	cursor = connection.cursor()
	118
516a2517 IB	119	if user is None:
	120	cursor.execute("SELECT config,user_id FROM market_configs")
	121	else:
	122	cursor.execute("SELECT config,user_id FROM market_configs WHERE user_id = %s", user)
f86ee140 IB	123
	124	for row in cursor:
	125	yield row
	126
23f4616a IB	127	def main_process_market(user_market, actions, before=False, after=False):
23f4616a IB	128	if len(actions or []) == 0:
516a2517	129	if before:
9db7d156	130	Processor(user_market).process("sell_all", steps="before")
516a2517	131	if after:
9db7d156	132	Processor(user_market).process("sell_all", steps="after")
516a2517	133	else:
23f4616a IB	134	for action in actions:
	135	if action in globals():
	136	(globals()[action])(user_market)
	137	else:
	138	raise NotImplementedError("Unknown action {}".format(action))
f86ee140 IB	139
f86ee140 IB	140	def main_store_report(report_path, user_id, user_market):
6ca5a1ec	141	try:
f86ee140 IB	142	if report_path is not None:
	143	report_file = "{}/{}_{}.json".format(report_path, datetime.now().isoformat(), user_id)
	144	with open(report_file, "w") as f:
	145	f.write(user_market.report.to_json())
	146	except Exception as e:
	147	print("impossible to store report file: {}; {}".format(e.__class__.__name__, e))
6ca5a1ec IB	148
6ca5a1ec IB	149	def print_orders(market, base_currency="BTC"):
f86ee140 IB	150	market.report.log_stage("print_orders")
	151	market.balances.fetch_balances(tag="print_orders")
	152	market.prepare_trades(base_currency=base_currency, compute_value="average")
	153	market.trades.prepare_orders(compute_value="average")
6ca5a1ec	154
97922ff1	155	def print_balances(market, base_currency="BTC"):
f70bb858	156	market.report.log_stage("print_balances")
f86ee140	157	market.balances.fetch_balances()
97922ff1	158	if base_currency is not None:
f86ee140 IB	159	market.report.print_log("total:")
	160	market.report.print_log(sum(market.balances.in_currency(base_currency).values()))
	161
9db7d156 IB	162	class Processor:
	163	scenarios = {
	164	"sell_needed": [
	165	{
	166	"name": "wait",
	167	"number": 0,
	168	"before": False,
	169	"after": True,
	170	"wait_for_recent": {},
	171	},
	172	{
	173	"name": "sell",
	174	"number": 1,
	175	"before": False,
	176	"after": True,
	177	"fetch_balances": ["begin", "end"],
	178	"prepare_trades": {},
	179	"prepare_orders": { "only": "dispose", "compute_value": "average" },
	180	"run_orders": {},
	181	"follow_orders": {},
	182	},
	183	{
	184	"name": "buy",
	185	"number": 2,
	186	"before": False,
	187	"after": True,
	188	"fetch_balances": ["begin", "end"],
	189	"prepare_trades": { "only": "acquire" },
	190	"prepare_orders": { "only": "acquire", "compute_value": "average" },
	191	"move_balances": {},
	192	"run_orders": {},
	193	"follow_orders": {},
	194	},
	195	],
	196	"sell_all": [
	197	{
	198	"name": "all_sell",
	199	"number": 1,
	200	"before": True,
	201	"after": False,
	202	"fetch_balances": ["begin", "end"],
	203	"prepare_trades": { "repartition": { "BTC": (1, "long") } },
	204	"prepare_orders": { "compute_value": "average" },
	205	"run_orders": {},
	206	"follow_orders": {},
	207	},
	208	{
	209	"name": "wait",
	210	"number": 2,
	211	"before": False,
	212	"after": True,
	213	"wait_for_recent": {},
	214	},
	215	{
	216	"name": "all_buy",
	217	"number": 3,
	218	"before": False,
	219	"after": True,
	220	"fetch_balances": ["begin", "end"],
	221	"prepare_trades": {},
	222	"prepare_orders": { "compute_value": "average" },
	223	"move_balances": {},
	224	"run_orders": {},
	225	"follow_orders": {},
226	},
227	]
228	}
229
230	allowed_arguments = {
231	"wait_for_recent": ["delta"],
232	"prepare_trades": ["base_currency", "liquidity", "compute_value", "repartition", "only"],
233	"prepare_orders": ["only", "compute_value"],
234	"move_balances": [],
235	"run_orders": [],
236	"follow_orders": ["sleep"],
237	}
238
239	def __init__(self, market):
240	self.market = market
241
242	def select_steps(self, scenario, step):
243	if step == "all":
244	return scenario
245	elif step == "before" or step == "after":
246	return list(filter(lambda x: step in x and x[step], scenario))
247	elif type(step) == int:
248	return [scenario[step-1]]
249	elif type(step) == str:
250	return list(filter(lambda x: x["name"] == step, scenario))
251	else:
252	raise TypeError("Unknown step {}".format(step))
253
254	def process(self, scenario_name, steps="all", **kwargs):
255	scenario = self.scenarios[scenario_name]
256	selected_steps = []
257
258	if type(steps) == str or type(steps) == int:
259	selected_steps += self.select_steps(scenario, steps)
260	else:
261	for step in steps:
262	selected_steps += self.select_steps(scenario, step)
263	for step in selected_steps:
264	self.process_step(scenario_name, step, **kwargs)
265
266	def process_step(self, scenario_name, step, **kwargs):
267	process_name = "process_{}__{}_{}".format(scenario_name, step["number"], step["name"])
268	self.market.report.log_stage("{}_begin".format(process_name))
269	if "begin" in step.get("fetch_balances", []):
270	self.market.balances.fetch_balances(tag="{}_begin".format(process_name))
271
272	for action in ["wait_for_recent", "prepare_trades",
273	"prepare_orders", "move_balances", "run_orders",
274	"follow_orders"]:
275	if action in step:
276	self.run_action(action, step[action], **kwargs)
277
278	if "end" in step.get("fetch_balances", []):
279	self.market.balances.fetch_balances(tag="{}_end".format(process_name))
280	self.market.report.log_stage("{}_end".format(process_name))
281
282	def run_action(self, action, default_args, **kwargs):
283	args = {k: v for k, v in {default_args, kwargs}.items() if k in self.allowed_arguments[action] }
284
285	if action == "wait_for_recent":
286	portfolio.Portfolio.wait_for_recent(self.market, **args)
287	if action == "prepare_trades":
288	self.market.prepare_trades(**args)
289	if action == "prepare_orders":
290	self.market.trades.prepare_orders(**args)
291	if action == "move_balances":
292	self.market.move_balances(**args)
293	if action == "run_orders":
294	self.market.trades.run_orders(**args)
295	if action == "follow_orders":
296	self.market.follow_orders(**args)
297
f86ee140	298	def process_sell_needed__1_sell(market, liquidity="medium", base_currency="BTC"):
9db7d156 IB	299	Processor(market).process("sell_needed", steps="sell",
9db7d156 IB	300	liquidity=liquidity, base_currency=base_currency)
f86ee140 IB	301
f86ee140 IB	302	def process_sell_needed__2_buy(market, liquidity="medium", base_currency="BTC"):
9db7d156 IB	303	Processor(market).process("sell_needed", steps="buy",
9db7d156 IB	304	liquidity=liquidity, base_currency=base_currency)
f86ee140 IB	305
f86ee140 IB	306	def process_sell_all__1_all_sell(market, base_currency="BTC", liquidity="medium"):
9db7d156 IB	307	Processor(market).process("sell_all", steps="all_sell",
9db7d156 IB	308	liquidity=liquidity, base_currency=base_currency)
f86ee140	309
065ee342	310	def process_sell_all__2_wait(market, liquidity="medium", base_currency="BTC"):
9db7d156 IB	311	Processor(market).process("sell_all", steps="wait",
9db7d156 IB	312	liquidity=liquidity, base_currency=base_currency)
065ee342 IB	313
065ee342 IB	314	def process_sell_all__3_all_buy(market, base_currency="BTC", liquidity="medium"):
9db7d156 IB	315	Processor(market).process("sell_all", steps="all_buy",
9db7d156 IB	316	liquidity=liquidity, base_currency=base_currency)
6ca5a1ec	317