├── requirements.txt
├── LICENSE
├── core
├── templates
│ ├── page_template.html
│ ├── main_page.html
│ └── jinja_templates.html
├── static
│ ├── css
│ │ └── style.css
│ └── js
│ │ ├── script.js
│ │ └── charts.js
├── botCore.py
└── trader.py
├── patterns.py
├── run.py
├── README.md
└── trader_configuration.py
/requirements.txt:
--------------------------------------------------------------------------------
1 | numpy
2 | requests
3 | flask
4 | flask-socketio==4.3.2
5 | websocket-client
6 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2021 John P Lennie
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/core/templates/page_template.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | Trader Control Panel
4 |
22 | Binance Trader Control Panel
23 |
24 |
25 | {% block content %}{% endblock content %}
26 |
27 |
29 |
--------------------------------------------------------------------------------
/core/static/css/style.css:
--------------------------------------------------------------------------------
1 | @import url('https://fonts.googleapis.com/css?family=Josefin+Sans&display=swap');
2 |
3 | *{
4 | margin: 0;
5 | padding: 0;
6 | box-sizing: border-box;
7 | list-style: none;
8 | text-decoration: none;
9 | font-family: arial;
10 | }
11 |
12 | body{
13 | background-color: #f3f5f9;
14 | display: flex;
15 | position: relative;
16 | }
17 |
18 | .sidebar{
19 | width: 200px;
20 | height: 100%;
21 | background: #4b4276;
22 | padding: 30px 0px;
23 | position: fixed;
24 | color: #bdb8d7;
25 | }
26 |
27 | .sidebar ul li{
28 | padding: 15px;
29 | }
30 |
31 | .sidebar ul li a{
32 | display: block;
33 | color: #bdb8d7;
34 | }
35 |
36 | .sidebar ul li:hover{
37 | background-color: #594f8d;
38 | }
39 |
40 | .sidebar ul li:hover a{
41 | color: #fff;
42 | }
43 |
44 | main {
45 | width: 100%;
46 | margin-left: 200px;
47 | background-color: #F5F5F0;
48 | padding-left: 20px;
49 | padding-top: 10px;
50 | }
51 |
52 | .trader-panel {
53 | display: none;
54 | }
55 |
56 | .small-button {
57 | padding: 5px;
58 | font-size: 12px;
59 | display: block;
60 | display: inline-block;
61 | border: none;
62 | border-radius: 4px;
63 | cursor: pointer;
64 | color: white;
65 | }
66 |
67 | .green-button {
68 | background-color: #00802b;
69 | }
70 |
71 | .green-button:hover {
72 | background-color: #33ff77;
73 | }
74 |
75 | .amber-button {
76 | background-color: #e68a00
77 | }
78 |
79 | .amber-button:hover {
80 | background-color: #ffa31a;
81 | }
--------------------------------------------------------------------------------
/core/templates/main_page.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | Trader Control Panel
4 |
35 | {{ overview_data_panel(data.market_symbols) }}
36 | {% for market_symbol in data.market_symbols %}
37 | {{ market_data_panel(market_symbol) }}
38 | {% endfor %}
39 |
40 |
41 |
42 |
--------------------------------------------------------------------------------
/core/templates/jinja_templates.html:
--------------------------------------------------------------------------------
1 | {% macro overview_data_panel(market_symbols) %}
2 |
3 | Trader Overview
4 |
5 | Total PL:
7 | {% for market_symbol in market_symbols %}
8 |
9 | Symbol: {{ market_symbol }} | State:
11 | {% endfor %}
12 |
13 | {% endmacro %}
14 |
15 |
16 | {% macro market_data_panel(market_symbol) %}
17 |
18 | {{ market_symbol }}
19 | Start
20 | Pause
21 |
22 | State: | Sell Price: | OP:
25 |
26 |
27 |
28 | {% endmacro %}
--------------------------------------------------------------------------------
/patterns.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | '''
3 | x : Price list
4 | y : Last comparible value.
5 | z : Historic comparible value.
6 |
7 | # find_high_high
8 | ( x : price list, y : last high, z : historic high value )
9 | Return highest value seen vs both recent and historically or None.
10 |
11 | # find_high
12 | ( x : price list, y : last high )
13 | Return the highest value seen or None.
14 |
15 | # find_low_high
16 | ( x : price list, y : last high, z : historic high value )
17 | Return highest value seen recently but lower historically or None.
18 |
19 | # find_low_low
20 | ( x : price list, y : last low, z : historic low value )
21 | Return the lowest value seen vs both recent and historically or None.
22 |
23 | # find_low
24 | ( x : price list, y : last low )
25 | Return the lowest value seen or None.
26 |
27 | # find_high_low
28 | ( x : price list, y : last low, z : historic low value )
29 | Return lowest value seen recently but higher historically or None.
30 | '''
31 | ## High setups
32 | find_high_high = lambda x, y, z: x.max() if z < x.max() > y else None
33 | find_high = lambda x, y: x.max() if x.max() > y else None
34 | find_low_high = lambda x, y, z: x.max() if z > x.max() > y else None
35 | ## Low setup
36 | find_low_low = lambda x, y, z: x.min() if z > x.min() < y else None
37 | find_low = lambda x, y: x.min() if x.min() < y else None
38 | find_high_low = lambda x, y, z: x.min() if z < x.min() < y else None
39 |
40 | """
41 | Trading patterns.
42 |
43 | """
44 | class pattern_W:
45 | def __init__(self):
46 | self.required_points = 4
47 | self.result_points = 1 # Only required for testing to view outcome.
48 | self.segment_span = 4
49 | self.price_point = 0
50 |
51 | def check_condition(self, point_set):
52 | if point_set[3] > point_set[1] > point_set[2] > point_set[0]:
53 | print('part 1')
54 | if point_set[1] > point_set[2]+((point_set[3]-point_set[2])/2) and (100 - ((point_set[0]/point_set[2])*100)) < 1.2:
55 | print('part 2')
56 | return(True)
57 |
58 | return(False)
--------------------------------------------------------------------------------
/run.py:
--------------------------------------------------------------------------------
1 | #! /usr/bin/env python3
2 | import os
3 | import logging
4 | from core import botCore
5 |
6 | ## Setup
7 | cwd = os.getcwd()
8 | CACHE_DIR = 'cache/'.format(cwd)
9 | LOGS_DIR = 'logs/'.format(cwd)
10 |
11 | ## Settup logging.
12 | log_format = '%(asctime)s:%(name)s:%(message)s'
13 | logging.basicConfig(
14 | format=log_format,
15 | level=logging.INFO)
16 | logger = logging.getLogger()
17 |
18 | SETTINGS_FILE_NAME = 'settings.conf'
19 | DEFAULT_SETTINGS_DATA = '''# Public and Private key pais used for the for the trader.
20 | PUBLIC_KEY=
21 | PRIVATE_KEY=
22 |
23 | # Allow trader to be run in test mode (True/False).
24 | IS_TEST=True
25 |
26 | # Allow trader to be run in either spot or margin type.
27 | MARKET_TYPE=SPOT
28 |
29 | # Automatically update the BNB balance when low (for trading fees, only applicable to real trading)
30 | UPDATE_BNB_BALANCE=True
31 |
32 | # Interval used for the trader (1m, 3m, 5m, 15m, 30m, 1h, 2h, 4h, 6h, 8h, 12h, 1d, 3d).
33 | TRADER_INTERVAL=15m
34 |
35 | # The currency max the trader will use (in BTC) also note this scales up with the number of markets i.e. 2 pairs each market will have 0.0015 as their trading currency pair.
36 | TRADING_CURRENCY=0.002
37 |
38 | # The markets that will be traded (currently only BTC markets) seperate markets with a , for multi market trading.
39 | TRADING_MARKETS=BTC-ETH,BTC-LTC
40 |
41 | # Configuration for the webapp (default if left blank is IP=127.0.0.1, Port=5000)
42 | HOST_IP=
43 | HOST_PORT=
44 |
45 | # Configuration for the candle range and depth range (default if left bank is candles=500, Depth=50)
46 | MAX_CANDLES=
47 | MAX_DEPTH=
48 | '''
49 |
50 |
51 | def settings_reader():
52 | # Setting reader function to parse over the settings file and collect kv pairs.
53 |
54 | ## Setup settings file object with initial default variables.
55 | settings_file_data = {'public_key':'', 'private_key':'', 'host_ip':'127.0.0.1', 'host_port':5000, 'max_candles':500,'max_depth':50}
56 |
57 | ## Read the settings file and extract the fields.
58 | with open(SETTINGS_FILE_NAME, 'r') as f:
59 | for line in f.readlines():
60 |
61 | ### Check for kv line.
62 | if not('=' in line) or line[0] == '#':
63 | continue
64 |
65 | key, data = line.split('=')
66 |
67 | ### Check if data holds a value.
68 | if data == None or data == '\n':
69 | continue
70 |
71 | data = data.replace('\n', '')
72 |
73 | if key == 'IS_TEST':
74 | data = 'TEST' if data.upper() == 'TRUE' else 'REAL'
75 | key = 'run_type'
76 |
77 | elif key == 'MARKET_TYPE':
78 | data = data.upper()
79 |
80 | elif key == 'TRADING_MARKETS':
81 | data = data.replace(' ', '')
82 | data = data.split(',') if ',' in data else [data]
83 |
84 | elif key == 'HOST_IP':
85 | default_ip = '127.0.0.1'
86 |
87 | elif key == 'HOST_PORT':
88 | data = int(data)
89 |
90 | elif key == 'MAX_CANDLES':
91 | data = int(data)
92 |
93 | elif key == 'MAX_DEPTH':
94 | data = int(data)
95 |
96 | settings_file_data.update({key.lower():data})
97 |
98 | return(settings_file_data)
99 |
100 |
101 | if __name__ == '__main__':
102 |
103 | ## Check and make cache/logs dir.
104 | if not(os.path.exists(LOGS_DIR)):
105 | os.makedirs(LOGS_DIR, exist_ok=True)
106 | if not(os.path.exists(CACHE_DIR)):
107 | os.makedirs(CACHE_DIR, exist_ok=True)
108 |
109 | ## Load settings/create settings file.
110 | if os.path.exists(SETTINGS_FILE_NAME):
111 | settings = settings_reader()
112 | botCore.start(settings, LOGS_DIR, CACHE_DIR)
113 | else:
114 | with open(SETTINGS_FILE_NAME, 'w') as f:
115 | f.write(DEFAULT_SETTINGS_DATA)
116 | print('Created settings.conf file.')
117 |
118 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Simple Binance Trader
2 |
3 | # Disclaimer
4 | I am not responsible for the trades you make with the script, this script has not been exstensivly tested on live trades.
5 |
6 | ## Please check the following:
7 | - Make sure your account uses BNB for the trade fees and that you have plenty of BNB for the trader to use for trades as if not there will be issues with the trader.
8 | - Please clear any cache files when updating the trader as there may be issues if not.
9 | - Please if any updates are also available for binance_api or the technical indicators update those also.
10 |
11 |
12 | NOTE: The current strtergy is also very weak and will mostlikley return only losses therefore I recomend you create your work or use some which would work. However the trader currently also does not support simulated trades and only support live trading, simulated trades should be added in the future so you may need to wait until then to use this to test stratergies.
13 |
14 | NOTE: Trader now supports MARGIN trades allowing the placement of short and long positions. If SPOT trading put your conditions within the "long_entry/long_exit" sections within the trader_configuration.py file.
15 |
16 |
17 | ## Description
18 | This is a simple binance trader that uses the REST api and sockets to allow automation or manipulation of account detail/data. The script which in the default configuration uses a basic MACD trading setup to trade. The script however is very customisable and you'll be able to configure it as you with via the help of the document in the usage section.
19 |
20 | ### Repository Contains:
21 | - run.py : This is used to start/setup the bot.
22 | - trader_configuration.py : Here is where you write your conditions using python logic.
23 | - patterns.py : Can be used to trade based on specific patterns.
24 | - Core
25 | - botCore.py : Is used to manage the socket and trader as well as pull data to be displayed.
26 | - trader.py : The main trader inchage or updating and watching orders.
27 | - static : Folder for static files for the website (js/css).
28 | - templates : Folder for HTML page templates.
29 |
30 | ### Setting File:
31 | - PUBLIC_KEY - Your public binanace api key
32 | - PRIVATE_KEY - Your private binanace api key
33 | - IS_TEST - Allow trader to be run in test mode (True/False)
34 | - MARKET_TYPE - Market type to be traded (SPOT/MARGIN)
35 | - UPDATE_BNB_BALANCE - Automatically update the BNB balance when low (for trading fees, only applicable to real trading)
36 | - TRADER_INTERVAL - Interval used for the trader (1m, 3m, 5m, 15m, 30m, 1h, 2h, 4h, 6h, 8h, 12h, 1d, 3d).
37 | - TRADING_CURRENCY - The currency max the trader will use (in the quote key) also note this scales up with the number of markets i.e. 2 pairs each market will have 0.0015 as their trading currency pair.
38 | - TRADING_MARKETS - The markets that are being traded and seperate with ',' (BTC-ETH,BTC-NEO)
39 | - HOST_IP - The host IP for the web UI (if left blank default is 127.0.0.1)
40 | - HOST_PORT - The host port for the web UI (if left blank default is 5000)
41 | - MAX_CANDLES - Max candles the trader will use (if left brank default is 500)
42 | - MAX_DEPTH - Max market depth the trader will use (if left brank default is 50)
43 |
44 | ## Usage
45 | I recommend setting this all up within a virtual python enviornment:
46 | First get the base modules:
47 | - To quickly install all the required modules use 'pip3 install -r requirements'.
48 |
49 | Secondly get the required techinal indicators module adn binance api.
50 | - https://github.com/EasyAI/binance_api, This is the binance API that the trader uses.
51 | - https://github.com/EasyAI/Python-Charting-Indicators, This contains the logic to calculate technical indicators. (only the file technical_indicators.py is needed)
52 |
53 | Move them into the site-packages folder. NOTE: If you get an error saying that either the technical_indicators or binance_api is not found you can move them in to the same directory as the run.py file for the trader.
54 |
55 | Finally navigate to the trader directory.
56 |
57 | To set up the bot and for any further detail please refer to the google doc link below:
58 | https://docs.google.com/document/d/1VUx_1O5kQQxk0HfqqA8WyQpk6EbbnXcezAdqXkOMklo/edit?usp=sharing
59 |
60 | ### Contact
61 | Please if you find any bugs or issues contact me so I can improve.
62 | EMAIL: jlennie1996@gmail.com
63 |
--------------------------------------------------------------------------------
/core/static/js/script.js:
--------------------------------------------------------------------------------
1 | //
2 | //
3 | const socket = io('http://'+ip+':'+port);
4 |
5 | const class_data_mapping = {
6 | 'trader-state':'runtime_state',
7 | 'trader-lastupdate':'last_update_time',
8 | 'trader-lastprice':'lastPrice',
9 | 'trader-markettype':'order_market_type',
10 | 'trader-orderside':'order_side',
11 | 'trader-ordertype':'order_type',
12 | 'trader-orderstatus':'order_status',
13 | 'trader-buyprice':'price',
14 | 'trader-sellprice':'price',
15 | 'trader-orderpoint':'order_point'
16 | };
17 |
18 | var current_chart = '';
19 | var update_chart = false;
20 |
21 |
22 | $(document).ready(function() {
23 | socket.on('current_traders_data', function(data) {
24 | update_trader_results(data);
25 | });
26 | });
27 |
28 |
29 | function update_trader_results(data) {
30 | //
31 | var currentTraders = data['data'];
32 |
33 | var overall_total_trades = 0;
34 | var overall_total_pl = 0;
35 |
36 | for (x = 0; x < (currentTraders.length); x++){
37 | var current = currentTraders[x];
38 | var trade_recorder = current['trade_recorder'];
39 | var update_targets = [`trader_${current['market']}`, `overview_${current['market']}`]
40 |
41 | for (i = 0; i < (update_targets.length); i++){
42 | var trader_panel = document.getElementById(update_targets[i]);
43 | var target_el = null;
44 |
45 | for (var key in class_data_mapping) {
46 | target_el = trader_panel.getElementsByClassName(key);
47 | if (target_el.length != 0) {
48 | if (current['order_side'] == 'SELL' && key == 'trader-buyprice') {
49 | show_val = trade_recorder[trade_recorder.length-1][1];
50 | } else {
51 | show_val = current[class_data_mapping[key]];
52 | }
53 |
54 | if (show_val === null) {
55 | show_val = 'Null';
56 | }
57 | target_el[0].innerText = show_val;
58 | }
59 | }
60 |
61 | target_el = trader_panel.getElementsByClassName('show-sellaction');
62 | if (target_el.length != 0) {
63 | if (current['order_side'] == 'SELL') {
64 | target_el[0].style.display = 'block';
65 | } else {
66 | target_el[0].style.display = 'none';
67 | }
68 | }
69 |
70 | var outcome = 0;
71 | var total_trades = 0;
72 | if (trade_recorder.length >= 2) {
73 | range = trade_recorder.length/2
74 | for (y = 0; y < (range); y++) {
75 | buy_order = trade_recorder[(range*2)-2]
76 | sell_order = trade_recorder[range*2-1]
77 |
78 | buy_value = buy_order[1]*buy_order[2]
79 | sell_value = sell_order[1]*buy_order[2]
80 |
81 | if (buy_order[3].includes("SHORT")) {
82 | outcome += buy_value-sell_value;
83 | } else {
84 | outcome += sell_value-buy_value;
85 | }
86 | total_trades += 1
87 | }
88 | }
89 |
90 | var r_outcome = Math.round(outcome*100000000)/100000000;
91 |
92 | target_el = trader_panel.getElementsByClassName('trader-trades')[0];
93 | target_el.innerText = total_trades;
94 | target_el = trader_panel.getElementsByClassName('trader-overall')[0];
95 | target_el.innerText = r_outcome;
96 |
97 | if (update_targets[i] != `overview_${current['market']}`) {
98 | overall_total_trades += total_trades;
99 | overall_total_pl += r_outcome;
100 | }
101 |
102 | if ((current_chart == update_targets[i]) && (update_chart == true) && current_chart != 'trader_Overview') {
103 | console.log(currentTraders);
104 | update_chart = false;
105 | target_el = trader_panel.getElementsByClassName('trader_charts')[0];
106 | build_chart(current['market'], target_el);
107 | }
108 | }
109 | }
110 | var overview_section = document.getElementById('trader_Overview');
111 |
112 | target_el = overview_section.getElementsByClassName('overview-totalpl')[0];
113 | target_el.innerText = overall_total_pl;
114 | target_el = overview_section.getElementsByClassName('overview-totaltrades')[0];
115 | target_el.innerText = overall_total_trades;
116 | }
117 |
118 |
119 | function hide_section(e, section_id){
120 |
121 | var section_el = document.getElementsByTagName('section');
122 | for (i = 0; i < (section_el.length); i++){
123 | if (section_el[i].id == `trader_${section_id}`) {
124 | current_chart = `trader_${section_id}`;
125 | update_chart = true;
126 | section_el[i].style.display = "block";
127 | } else {
128 | section_el[i].style.display = "none";
129 | }
130 | }
131 | }
132 |
133 |
134 | function start_trader(e, market_pair){
135 | e.preventDefault();
136 | rest_api('POST', 'trader_update', {'action':'start', 'market':market_pair});
137 | }
138 |
139 |
140 | function pause_trader(e, market_pair){
141 | e.preventDefault();
142 | rest_api('POST', 'trader_update', {'action':'pause', 'market':market_pair});
143 | }
144 |
145 |
146 | function build_chart(market_pair, element){
147 | rest_api('GET', `get_trader_charting?market=${market_pair}&limit=200`, null, initial_build, element);
148 | }
149 |
150 |
151 | function rest_api(method, endpoint, data=null, target_function=null, target_element=null){
152 | // if either the user has requested a force update on bot data or the user has added a new market to trade then send an update to the backend.
153 | console.log(`'M: ${method}, ULR: /rest-api/v1/${endpoint}, D:${data}`);
154 | let request = new XMLHttpRequest();
155 | request.open(method, '/rest-api/v1/'+endpoint, true);
156 |
157 | request.onload = function() {
158 | if (this.status == 200){
159 | var resp_data = JSON.parse(request.responseText);
160 | console.log(resp_data);
161 | if (target_function != null && target_element == null) {
162 | target_function(resp_data);
163 | } else if (target_function != null && target_element != null) {
164 | target_function(target_element, resp_data['data']);
165 | }
166 | } else {
167 | console.log(`error ${request.status} ${request.statusText}`);
168 | }
169 | }
170 |
171 | if (data == null){
172 | request.send();
173 | } else {
174 | request.setRequestHeader('content-type', 'application/json');
175 | request.send(JSON.stringify(data));
176 | }
177 | }
--------------------------------------------------------------------------------
/trader_configuration.py:
--------------------------------------------------------------------------------
1 | import logging
2 | import numpy as np
3 | import technical_indicators as TI
4 |
5 | ## Minimum price rounding.
6 | pRounding = 8
7 |
8 | def technical_indicators(candles):
9 | indicators = {}
10 |
11 | time_values = [candle[0] for candle in candles]
12 | open_prices = [candle[1] for candle in candles]
13 | high_prices = [candle[2] for candle in candles]
14 | low_prices = [candle[3] for candle in candles]
15 | close_prices = [candle[4] for candle in candles]
16 |
17 | indicators.update({'macd':TI.get_MACD(close_prices, time_values=time_values, map_time=True)})
18 |
19 | indicators.update({'ema':{}})
20 | indicators['ema'].update({'ema200':TI.get_EMA(close_prices, 200, time_values=time_values, map_time=True)})
21 |
22 | return(indicators)
23 |
24 | '''
25 | --- Current Supported Order ---
26 | Below are the currently supported order types that can be placed which the trader
27 | -- MARKET --
28 | To place a MARKET order you must pass:
29 | 'side' : 'SELL',
30 | 'description' : 'Long exit signal',
31 | 'order_type' : 'MARKET'
32 |
33 | -- LIMIT STOP LOSS --
34 | To place a LIMIT STOP LOSS order you must pass:
35 | 'side' : 'SELL',
36 | 'price' : price,
37 | 'stopPrice' : stopPrice,
38 | 'description' : 'Long exit stop-loss',
39 | 'order_type' : 'STOP_LOSS_LIMIT'
40 | -- LIMIT --
41 | To place a LIMIT order you must pass:
42 | 'side' : 'SELL',
43 | 'price' : price,
44 | 'description' : 'Long exit stop-loss',
45 | 'order_type' : 'LIMIT'
46 | -- OCO LIMIT --
47 | To place a OCO LIMIT order you must pass:
48 | 'side' : 'SELL',
49 | 'price' : price,
50 | 'stopPrice' : stopPrice,
51 | 'stopLimitPrice' : stopLimitPrice,
52 | 'description' : 'Long exit stop-loss',
53 | 'order_type' : 'OCO_LIMIT'
54 | --- Key Descriptions---
55 | Section will give brief descript of what each order placement key is and how its used.
56 | side = The side the order is to be placed either buy or sell.
57 | price = Price for the order to be placed.
58 | stopPrice = Stop price to trigger limits.
59 | stopLimitPrice = Used for OCO to to determine price placement for part 2 of the order.
60 | description = A description for the order that can be used to identify multiple conditions.
61 | order_type = The type of the order that is to be placed.
62 | --- Candle Structure ---
63 | Candles are structured in a multidimensional list as follows:
64 | [[time, open, high, low, close, volume], ...]
65 | '''
66 |
67 |
68 | def other_conditions(custom_conditional_data, trade_information, previous_trades, position_type, candles, indicators, symbol):
69 | # Define defaults.
70 | can_order = True
71 |
72 | # Setup additional extra conditions for trading.
73 | if trade_information['market_status'] == 'COMPLETE_TRADE':
74 | trade_information['market_status'] = 'TRADING'
75 |
76 | trade_information.update({'can_order':can_order})
77 | return(custom_conditional_data, trade_information)
78 |
79 |
80 | def long_exit_conditions(custom_conditional_data, trade_information, indicators, prices, candles, symbol):
81 | # Place Long exit (sell) conditions under this section.
82 | order_point = 0
83 | signal_id = 0
84 | macd = indicators['macd']
85 |
86 | if macd[0]['macd'] < macd[1]['macd']:
87 | order_point += 1
88 | if macd[1]['hist'] < macd[0]['hist']:
89 | return({'side':'SELL',
90 | 'description':'LONG exit signal 1',
91 | 'order_type':'MARKET'})
92 |
93 | stop_loss_price = float('{0:.{1}f}'.format((trade_information['buy_price']-(trade_information['buy_price']*0.004)), pRounding))
94 | stop_loss_status = basic_stoploss_setup(trade_information, stop_loss_price, stop_loss_price, 'LONG')
95 |
96 | # Base return for waiting and updating order positions.
97 | if stop_loss_status:
98 | return(stop_loss_status)
99 | else:
100 | return({'order_point':'L_ext_{0}_{1}'.format(signal_id, order_point)})
101 |
102 |
103 | def long_entry_conditions(custom_conditional_data, trade_information, indicators, prices, candles, symbol):
104 | # Place Long entry (buy) conditions under this section.
105 | order_point = 0
106 | signal_id = 0
107 | macd = indicators['macd']
108 | ema200 = indicators['ema']['ema200']
109 |
110 | if (candles[0][4] > ema200[0]):
111 | if macd[0]['macd'] > macd[1]['macd']:
112 | order_point += 1
113 | if macd[1]['hist'] > macd[0]['hist']:
114 | return({'side':'BUY',
115 | 'description':'LONG entry signal 1',
116 | 'order_type':'MARKET'})
117 |
118 | # Base return for waiting and updating order positions.
119 | if order_point == 0:
120 | return({'order_type':'WAIT'})
121 | else:
122 | return({'order_type':'WAIT', 'order_point':'L_ent_{0}_{1}'.format(signal_id, order_point)})
123 |
124 |
125 | def short_exit_conditions(custom_conditional_data, trade_information, indicators, prices, candles, symbol):
126 | ## Place Short exit (sell) conditions under this section.
127 | order_point = 0
128 | signal_id = 0
129 | macd = indicators['macd']
130 |
131 | if macd[0]['macd'] > macd[1]['macd']:
132 | order_point += 1
133 | if macd[1]['hist'] > macd[0]['hist']:
134 | return({'side':'SELL',
135 | 'description':'SHORT exit signal 1',
136 | 'order_type':'MARKET'})
137 |
138 | stop_loss_price = float('{0:.{1}f}'.format((trade_information['buy_price']+(trade_information['buy_price']*0.004)), pRounding))
139 | stop_loss_status = basic_stoploss_setup(trade_information, stop_loss_price, stop_loss_price, 'SHORT')
140 |
141 | # Base return for waiting and updating order positions.
142 | if stop_loss_status:
143 | return(stop_loss_status)
144 | else:
145 | return({'order_point':'S_ext_{0}_{1}'.format(signal_id, order_point)})
146 |
147 |
148 | def short_entry_conditions(custom_conditional_data, trade_information, indicators, prices, candles, symbol):
149 | ## Place Short entry (buy) conditions under this section.
150 | order_point = 0
151 | signal_id = 0
152 | macd = indicators['macd']
153 | ema200 = indicators['ema']['ema200']
154 |
155 | if (candles[0][4] < ema200[0]):
156 | if macd[0]['macd'] < macd[1]['macd'] and macd[0]['hist'] > macd[0]['macd']:
157 | order_point += 1
158 | if macd[1]['hist'] < macd[0]['hist']:
159 | return({'side':'BUY',
160 | 'description':'SHORT entry signal 1',
161 | 'order_type':'MARKET'})
162 |
163 | # Base return for waiting and updating order positions.
164 | if order_point == 0:
165 | return({'order_type':'WAIT'})
166 | else:
167 | return({'order_type':'WAIT', 'order_point':'S_ent_{0}_{1}'.format(signal_id, order_point)})
168 |
169 |
170 | def basic_stoploss_setup(trade_information, price, stop_price, position_type):
171 | # Basic stop-loss setup.
172 | if trade_information['order_type'] == 'STOP_LOSS_LIMIT':
173 | return
174 |
175 | return({'side':'SELL',
176 | 'price':price,
177 | 'stopPrice':stop_price,
178 | 'description':'{0} exit stop-loss'.format(position_type),
179 | 'order_type':'STOP_LOSS_LIMIT'})
--------------------------------------------------------------------------------
/core/static/js/charts.js:
--------------------------------------------------------------------------------
1 | // Indicator meta details
2 | const indicator_chart_types_mapping = {'patterns_data_lines':'line', 'patterns_data_points':'scatter', 'tops_bottoms':'scatter', 'data_lines':'line', 'cps':'line', 'ichi':'line', 'boll':'line', 'adx':'line', 'stock':'line', 'order':'scatter', 'ema':'line', 'sma':'line', 'rma':'line', 'rsi':'line', 'mfi':'line', 'cci':'line', 'zerolagmacd':'macd', 'macd':'macd'}
3 | const indicator_home_type_mapping = {'patterns_data_lines':'MAIN', 'patterns_data_points':'MAIN', 'tops_bottoms':'MAIN', 'data_lines':'MAIN', 'ichi':'MAIN', 'cps':'MAIN', 'boll':'MAIN', 'adx':'OWN', 'stock':'OWN', 'order':'MAIN', 'ema':'MAIN', 'sma':'MAIN', 'rma':'MAIN', 'rsi':'OWN', 'mfi':'OWN', 'cci':'OWN', 'zerolagmacd':'OWN', 'macd':'OWN'}
4 | const indicator_is_single_mapping = ['patterns_data_lines', 'patterns_data_points', 'tops_bottoms', 'data_lines', 'order', 'ema', 'sma', 'rma', 'rsi', 'mfi', 'cci', 'cps']
5 | const double_depth_indicators = ['ema', 'sma', 'order', 'patterns_data_points', 'patterns_data_lines'];
6 |
7 | // Base Apex chart configuration.
8 | window.Apex = {
9 | chart: {
10 | animations: {
11 | enabled: false
12 | }
13 | },
14 | autoScaleYaxis: false
15 | };
16 |
17 | // Chart template for main chart.
18 | var base_candle_chart_configuration = {
19 | series: [],
20 | chart: {
21 | height: 800,
22 | id: 'main_Chart',
23 | type: 'line'
24 | },
25 | fill: {
26 | type:'solid',
27 | },
28 | markers: {
29 | size: []
30 | },
31 | //colors: [],
32 | stroke: {
33 | width: []
34 | },
35 | tooltip: {
36 | shared: true,
37 | custom: []
38 | },
39 | xaxis: {
40 | type: 'datetime',
41 | },
42 | yaxis: {
43 | labels: {
44 | minWidth: 40,
45 | formatter: function (value) { return Math.round(value); }
46 | },
47 | }
48 | };
49 |
50 | let loaded_candles_chart = null;
51 |
52 |
53 | function initial_build(target_element, charting_data) {
54 | // Add main chandle chart position.
55 | var candle_data = charting_data['candles'];
56 | var indicator_data = charting_data['indicators'];
57 | var main_chart_series = [];
58 |
59 | loaded_candles_chart = JSON.parse(JSON.stringify(base_candle_chart_configuration));
60 |
61 | populate_chart(indicator_data);
62 |
63 | var built_data = build_candle_data(candle_data);
64 | var built_candle_data = built_data[0];
65 |
66 | // Finally add the candle to the displayed chart.
67 | loaded_candles_chart["series"].push({
68 | name: 'candle',
69 | type: 'candlestick',
70 | data: built_candle_data
71 | });
72 | loaded_candles_chart["stroke"]["width"].push(1);
73 | loaded_candles_chart["markers"]["size"].push(0);
74 | loaded_candles_chart["tooltip"]["custom"].push(function({seriesIndex, dataPointIndex, w}) {
75 | var o = w.globals.seriesCandleO[seriesIndex][dataPointIndex]
76 | var h = w.globals.seriesCandleH[seriesIndex][dataPointIndex]
77 | var l = w.globals.seriesCandleL[seriesIndex][dataPointIndex]
78 | var c = w.globals.seriesCandleC[seriesIndex][dataPointIndex]
79 | return (`Open:${o}