1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
from datetime import datetime
import argparse
import configparser
import psycopg2
import os
import sys
import market
import portfolio
__all__ = ["make_order", "get_user_market"]
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):
pg_config, report_path = parse_config(config_path)
market_config = list(fetch_markets(pg_config, str(user_id)))[0][0]
return market.Market.from_config(market_config, debug=debug)
def 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 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 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)")
parser.add_argument("--parallel", action='store_true', default=True, dest="parallel")
parser.add_argument("--no-parallel", action='store_false', dest="parallel")
args = parser.parse_args(argv)
if not os.path.exists(args.config):
print("no config file found, exiting")
sys.exit(1)
return args
def process(market_config, user_id, report_path, args):
try:
market.Market\
.from_config(market_config, debug=args.debug, user_id=user_id, report_path=report_path)\
.process(args.action, before=args.before, after=args.after)
except Exception as e:
print("{}: {}".format(e.__class__.__name__, e))
def main(argv):
args = parse_args(argv)
pg_config, report_path = parse_config(args.config)
if args.parallel:
import threading
market.Portfolio.start_worker()
for market_config, user_id in fetch_markets(pg_config, args.user):
threading.Thread(target=process, args=[market_config, user_id, report_path, args]).start()
else:
for market_config, user_id in fetch_markets(pg_config, args.user):
process(market_config, user_id, report_path, args)
if __name__ == '__main__': # pragma: no cover
main(sys.argv[1:])
|
