Die Ressourcen sind geladen. Beförderung...

Netzmanagement-Tools

Schriftsteller:Programm, Datum: 2023-04-30 09.03:58
Tags:

Parameter Ist es notwendig? Beschreibung
Höherer_Preis - Nein Die Grenzpreise im Netz
niedrigerer_Preis - Nein Preis unterhalb der Grenze
Grid_num - Nein Anzahl der Netze (nicht gleich)
Abstand - Nein Gitterintervall (gleiche Relation)
Seite - Nein Unterstützung für die ÜbertragunglongshortDas ist die Standard-Nummer.long
Daten - Nein Es gibt bereits eine Gitterinformation mit dem Typ Dictionary.
# 创建了一个价格1000-800,数量为10的等差网格
GridPriceManager(upper_price=1000, lower_price=800, grid_num=10)

# 创建了一个价格1000-800,间隔为1%的等比网格
GridPriceManager(upper_price=1000, lower_price=800, interval=1)

# 传入已有网格信息
data = {
	"grid_list":    {99:None,100:None,101:None,102:None,103:None,104:None},
	"interval":     None,
	"upper_price":  104,
	"lower_price":  99,
	"grid_num":     6,
	"side":         "long",
	"grid_diff":    1,
	"type":         "等差",
}
GridPriceManager(Data=data)

Datenstrukturen

Parameter Ist es notwendig? Beschreibung
Netz_Liste - Ja, das ist es. Gitterpreise und Bestellinformationen, die mit einem Schlüsselwert gespeichert werden, key als Preis und value als Bestell-id
Abstand - Ja, das ist es.
Höherer_Preis - Ja, das ist es.
niedrigerer_Preis - Ja, das ist es.
Grid_num - Ja, das ist es.
Seite - Ja, das ist es.
Grid_diff - Ja, das ist es.
Typ - Ja, das ist es. Gleichung oder Gleichung

Funktionen

  • Get_nearest_buy_price (aktueller Preis)

    Erhalten Sie die letzten Netzpreise

    Parameter Ist es notwendig? Beschreibung
    aktueller_Preis - Ja, das ist es. Einladen, um den letzten Kaufpreis zu finden
  • Get_nearest_sell_price (aktueller Preis)

    Erhalten Sie die jüngsten Verkaufspreise

    Parameter Ist es notwendig? Beschreibung
    aktueller_Preis - Ja, das ist es. Einladen, um den letzten Verkauf zu finden
  • Basis_Position (Tick)

    Unterhaus

    Parameter Ist es notwendig? Beschreibung
    Zähne - Ja, das ist es. Öffnen Sie den Unterhalter, um das Gitter zu öffnen, das die Rückruffunktion ausführteventEreignissebase_position
  • Add_order (Order_id)

    Hinzufügen von Anzeigen auf dem Netz

    Parameter Ist es notwendig? Beschreibung
    Ausgabe - Ja, das ist es. Die id-Funktion, bei der ein Legen, ein Übertragen oder ein Transaktionsbestellungen auf dem Gitter hinzugefügt wird, findet das Up-down-Gitter dieser id und führt die Rückruffunktion aus.eventEreignisseadd_order
  • Absagen von Bestellungen

    Rücktritt der Bestellung

    Parameter Ist es notwendig? Beschreibung
    Ausgabe - Ja, das ist es. Widerrufen des angegebenen Auftrags, die eine Rückruffunktion ausführteventEreignissecancel_order

Ereignisse

Ereignisse sind spezifische Rückruffunktionen, die während der Funktionsausführung aufgerufen werden, wobei die Event-Funktion immer die spezifische Ereignisübertragung, Dekorationsmodus verwendet.

gm = GridPriceManager(1000, 800, 10)

# 底仓事件,在调用base_position方法时会触发此事件
@gm.event('base_position')
def base_position(price):
    # 传入最近的网格价格,以此价格作为买入价格参考
    print(price)
    return 123456	# 返回底仓订单,manger将订单记录
Ereignisse Ist es notwendig? Übertragung Zurück
Basis_Position - Ja, das ist es. Preis, Kaufpreis, Float Typ Bestellungs-ID der Lagerstätte
Add_order wird verwendet. - Nein Preis, Einkaufspreis im Netz, Dict-Typ, {up: Preis im Netz,down: Preis im Netz} Mit einem Dict, der in demselben Format übertragen wird, korrespondiert die Up Grid Transaktionsid, die Down Grid Transaktionsid
Absagen_bestellen - Nein order_id, geben Sie den Typ der aufgehobenen Bestellungen an bool, erfolgreich widerrufen
Veränderung - Nein Netz_Liste Das ist eine Änderung der Netzinformationen, die den Vorfall auslöste.

class GridPriceManager:
    def __init__(self, Data=None, upper_price=None, lower_price=None, interval=None, grid_num=None, side: Literal['long','short']='long') -> dict:
        self.interval = interval
        self.upper_price = upper_price
        self.lower_price = lower_price
        self.grid_num = grid_num
        self.side = side
        self.grid_diff = None
        self.type = None    # 网格类型
        if self.grid_num is not None:
            self.grid_diff = (self.upper_price - self.lower_price) / (self.grid_num - 1)
        if Data is None: 
            if self.interval is None:
                self.grid_list = self._generate_grid_list_difference()
                self.type = "等差"
            else:
                self.grid_list = self._generate_grids_list_ratio()
                self.type = "等比"
        else:
            self.grid_list = Data["grid_list"]
            self.interval = Data["interval"]
            self.upper_price = Data["upper_price"]
            self.lower_price = Data["lower_price"]
            self.grid_num = Data["grid_num"]
            self.side = Data["side"]
            self.grid_diff = Data["grid_diff"]
            self.type = Data["type"]
        self.data = f"网格类型: {self.type}, 网格数量: {len(self.grid_list)}, 上下区间: [{self.upper_price}-{self.lower_price}, 方向: {self.side}]"
        self.callback = {}

    def event(self, event_name):
        """事件"""
        def decorator(func):
            self.callback[event_name] = func
            return func
        return decorator

    def _generate_grid_list_difference(self) -> dict:
        """等差网格生成"""
        grid_list = {}
        price = self.lower_price
        for _ in range(self.grid_num):
            grid_list[price] = None
            price += self.grid_diff
        grid_list[self.upper_price] = None
        return grid_list

    def _generate_grids_list_ratio(self) -> dict:
        """等比网格生成"""
        ratio = 1 + self.interval / 100
        grid = [self.lower_price * (ratio ** i) for i in range(-100, 101)]
        return {round(g, 8): None for g in grid if self.lower_price <= g <= self.upper_price}


    def get_nearest_buy_price(self, current_price) -> float:
        """获取最近网格买入价格"""
        nearest_price = None
        for price in sorted(self.grid_list.keys()):
            if price > current_price:
                break
            nearest_price = price
        return nearest_price

    def get_nearest_sell_price(self, current_price) -> float:
        """获取最近网格卖出价格"""
        nearest_price = None
        for price in sorted(self.grid_list.keys(), reverse=True):
            if price < current_price:
                break
            nearest_price = price
        return nearest_price
    
    def base_position(self, ticker) -> Union[str, int]:
        """底仓"""
        if self.side == "short":
            t = self.get_nearest_sell_price(ticker)
        else:
            t = self.get_nearest_buy_price(ticker)
        order_id = self.callback["base_position"](t)
        self.grid_list[t] = order_id
        self.callback["change"](self.grid_list)
        return order_id
    
    def add_order(self, order_id) -> Union[Dict, bool]:
        """增加网格上下挂单"""
        up_price = None
        down_price = None
        ticker = None
        keys = list(self.grid_list.keys())
        for i in range(len(keys)-1):
            if self.grid_list[keys[i]] == order_id:
                ticker = keys[i]
                try:
                    if self.side is None or self.side == "long":
                        up_price = keys[i+1]
                        down_price = keys[i-1]
                    else:
                        up_price = keys[i-1]
                        down_price = keys[i+1]
                except IndexError:
                    return False
                break

        PriceDict = {"up": up_price, "down": down_price}
        d = self.callback["add_order"](PriceDict)
        d = {"up": d["up"], "down": d["down"]}
        self.grid_list[up_price] = d["up"]
        self.grid_list[down_price] = d["down"]
        self.grid_list[ticker] = None
        self.callback["change"](self.grid_list)
        return d
    
    def cancel_order(self, order_id):
        """撤销订单"""
        result = self.callback["cancel_order"](order_id)
        if result == True:
            for items in self.grid_list.items():
                if items[1] == order_id:
                    self.grid_list[items[0]] = None
                    self.callback["change"](self.grid_list)
                    break

def main():
    gm = GridPriceManager(1000, 500, 10)

    @gm.event('add_order')
    def add_order(price):
        print(price)
        return {
            'up': 36543,
            'down': 87957,
        }

    @gm.event('cancel_order')
    def cancel_order(order_id):
        return True

    @gm.event('base_position')
    def base_position(price):
        print(price)
        return 123456

    a = gm.base_position(600)
    print(a)
    a = gm.add_order(123456)
    print(gm.grid_list)
    gm.cancel_order(87957)
    print(gm.grid_list)

Mehr