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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
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:
process_sell_all__1_all_sell(user_market)
if after:
portfolio.Portfolio.wait_for_recent(user_market)
process_sell_all__2_all_buy(user_market)
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()))
def process_sell_needed__1_sell(market, liquidity="medium", base_currency="BTC"):
market.report.log_stage("process_sell_needed__1_sell_begin")
market.balances.fetch_balances(tag="process_sell_needed__1_sell_begin")
market.prepare_trades(liquidity=liquidity, base_currency=base_currency)
market.trades.prepare_orders(compute_value="average", only="dispose")
market.trades.run_orders()
market.follow_orders()
market.balances.fetch_balances(tag="process_sell_needed__1_sell_end")
market.report.log_stage("process_sell_needed__1_sell_end")
def process_sell_needed__2_buy(market, liquidity="medium", base_currency="BTC"):
market.report.log_stage("process_sell_needed__2_buy_begin")
market.balances.fetch_balances(tag="process_sell_needed__2_buy_begin")
market.update_trades(base_currency=base_currency, liquidity=liquidity, only="acquire")
market.trades.prepare_orders(compute_value="average", only="acquire")
market.move_balances()
market.trades.run_orders()
market.follow_orders()
market.balances.fetch_balances(tag="process_sell_needed__2_buy_end")
market.report.log_stage("process_sell_needed__2_buy_end")
def process_sell_all__1_all_sell(market, base_currency="BTC", liquidity="medium"):
market.report.log_stage("process_sell_all__1_all_sell_begin")
market.balances.fetch_balances(tag="process_sell_all__1_all_sell_begin")
market.prepare_trades_to_sell_all(base_currency=base_currency)
market.trades.prepare_orders(compute_value="average")
market.trades.run_orders()
market.follow_orders()
market.balances.fetch_balances(tag="process_sell_all__1_all_sell_end")
market.report.log_stage("process_sell_all__1_all_sell_end")
def process_sell_all__2_all_buy(market, base_currency="BTC", liquidity="medium"):
market.report.log_stage("process_sell_all__2_all_buy_begin")
market.balances.fetch_balances(tag="process_sell_all__2_all_buy_begin")
market.prepare_trades(liquidity=liquidity, base_currency=base_currency)
market.trades.prepare_orders(compute_value="average")
market.move_balances()
market.trades.run_orders()
market.follow_orders()
market.balances.fetch_balances(tag="process_sell_all__2_all_buy_end")
market.report.log_stage("process_sell_all__2_all_buy_end")
|
