当前位置:网站首页>Multi robot market share solution

Multi robot market share solution

2020-11-06 20:21:54 Inventor quantification

Multi robot market sharing solution

When trading digital money, use robots , When you have to run multiple robots on a server , If you visit different exchanges , It's not a big problem at this time , There will be no API The frequency of requests . If you need to have multiple robots running at the same time , And they all do the same exchange , The quantitative trading strategy of the same trading pair . At this time there is API The request frequency limit problem . How to use the least number of server interfaces to solve the problem ?

We can implement a market forwarding robot , Access to the exchange interface to obtain market data and other data, only this robot to complete . Other trading strategy robots forward robot request data to this market .

Quote forwarding robot example

Only responsible for accessing the exchange market interface to obtain data , And offer other robots a market . Use Python To write , In the example, we only get K Line data , And provide sharing , Can be expanded to increase depth data , Aggregate market data, etc .

import _thread
import threading
import json
import math
from http.server import HTTPServer, BaseHTTPRequestHandler
from urllib.parse import parse_qs, urlparse

Records = None
lock = threading.RLock()
Counter = {}

def url2Dict(url):
    query = urlparse(url).query  
    params = parse_qs(query)  
    result = {key: params[key][0] for key in params}  
    return result

class Provider(BaseHTTPRequestHandler):
    def do_GET(self):
        global Records, lock, Counter
        try:
            self.send_response(200)
            self.send_header("Content-type", "application/json")
            self.end_headers()

            dictParam = url2Dict(self.path)
            # Log(" The service received the request ,self.path:", self.path, "query  Parameters :", dictParam)
            lock.acquire()
            #  Record 
            if dictParam["robotId"] not in Counter:
                Counter[dictParam["robotId"]] = {"NumberOfRequests" : 0}
            Counter[dictParam["robotId"]]["NumberOfRequests"] += 1
            lock.release()
            
            #  Write data response 
            self.wfile.write(json.dumps(Records).encode())
        except BaseException as e:
            Log("Provider do_GET error, e:", e)


def createServer(host):
    try:
        server = HTTPServer(host, Provider)
        Log("Starting server, listen at: %s:%s" % host)
        server.serve_forever()
    except BaseException as e:
        Log("createServer error, e:", e)
        raise Exception("stop")

def main():
    global Records, Counter
    LogReset(1)
    try:
        # _thread.start_new_thread(createServer, (("localhost", 9090), ))         #  Native test 
        _thread.start_new_thread(createServer, (("0.0.0.0", 9090), ))             # VPS Test on server 
        Log(" Start the service ", "#FF0000")
    except BaseException as e:
        Log(" Failed to start service !")
        Log(" error message :", e)
        raise Exception("stop")
    while True:
        r = exchange.GetRecords()
        if not r :
            Log("K Line market acquisition failed ", "#FF0000")
            continue
        else :
            Records = r
        # Counter
        tbl = {
            "type" : "table", 
            "title" : " Statistics ", 
            "cols" : [" Robots that request data id", " Number of requests "], 
            "rows" : [], 
        }
        for k in Counter:
            tbl["rows"].append([k, Counter[k]["NumberOfRequests"]])
        LogStatus(_D(), " Data collection !", "\n", "`" + json.dumps(tbl) + "`")
        Sleep(500)
        

Request data robot policy code

The robot that requests data is the trading strategy robot , It's just that we use , Write only the request data (K Line data ) And draw the data , It can be used JavaScript To write , For drawing , You need to check 「 Draw line class library 」 You can search and copy this library in strategy square , After copying, you can check the column of template reference in the policy editing page .

var FuncGetRecords = exchange.GetRecords
exchange.GetRecords = function() {
    //  Can be filled in 「 Market forwarding robot 」 Of the device IP Address xxx.xxx.xxx.xxx
    var ret = HttpQuery("http://xxx.xxx.xxx.xxx:9090?robotId=" + _G())  
    var records = null
    try {
        records = JSON.parse(ret)
    } catch(e) {
        Log(e)
        records = null
    }
    return records 
}

function main(){
    LogReset(1)
    while(1) {
        var records = exchange.GetRecords()
        LogStatus(_D(), " robot ID:", _G())
        if (!records) {
            Log(" Failed to get data !", "#FF0000")
            Sleep(1000)
            continue
        }
        Log(records)
        $.PlotRecords(records, "K")
        Sleep(1000)
    }
}

Actual operation

  • Start the market forwarding robot

  • Start the test robot ,ID:206353

  • Start the test robot ,ID:206359

  • Start the test robot ,ID:206360

In this way, three or even N A robot for a deal for K Sharing of line data .
throw away a brick in order to get a gem , Welcome to leave a message .

版权声明
本文为[Inventor quantification]所创,转载请带上原文链接,感谢