L后成交太快撤单

Administrator

2024-01-19 a00da3062c6c825b585f82275823ac45cdeb6502

 third_data/history_k_data_util.py

@@ -1,11 +1,99 @@
"""
历史K线服务
"""
import datetime
import decimal
import json
import time

import tool
from db import redis_manager
import gm.api as gmapi
import requests

import constant
from db.redis_manager_delegate import RedisUtils
from log_module.log import logger_request_api
from utils import tool, middle_api_protocol
from db import redis_manager_delegate as redis_manager


# import gm.api as gmapi


class JueJinHttpApi:
    __BASE_URL = "http://193.112.35.168:10009/"

    @classmethod
    def __request(cls, path_str, data_json):
        def deformat_date(val):
            if type(val) == str and val.find('T') > -1 and val.find(':') > -1 and val.find(
                    '+') > -1:
                return datetime.datetime.fromisoformat(val)
            return val

        DELEGATE = True
        fdata = None
        if DELEGATE:
            fdata = middle_api_protocol.load_juejin(path_str, data_json)
            __start_time = time.time()
            try:
                fdata = middle_api_protocol.request(fdata)
            finally:
                __use_time = time.time() - __start_time
                if __use_time > 5:
                    logger_request_api.info(f"掘金API请求时间：{path_str}-{int(__use_time)}")

        else:
            url = f'{cls.__BASE_URL}{path_str}'
            # 发送POST请求
            response = requests.post(url, json=data_json)
            result = response.text
            resultJson = json.loads(result)
            if resultJson['code'] == 0:
                fdata = resultJson['data']
        if fdata:
            if type(fdata) == list:
                for d in fdata:
                    if type(d) != dict:
                        continue
                    for k in d:
                        d[k] = deformat_date(d[k])
            elif type(fdata) == dict:
                for k in fdata:
                    fdata[k] = deformat_date(fdata[k])
            return fdata
        else:
            return None

    @classmethod
    def get_instruments(cls, symbols, fields):
        return cls.__request("get_instruments", {"symbols": symbols, "fields": fields})

    @classmethod
    def history_n(cls, symbol, frequency, count, adjust, fields):
        return cls.__request("history_n", {"symbol": symbol, "frequency": frequency, "count": count, "adjust": adjust,
                                           "fields": fields})

    @classmethod
    def current(cls, symbols, fields):
        return cls.__request("current", {"symbols": symbols, "fields": fields})

    @classmethod
    def get_exchanges_codes(cls, exchanges, sec_types, skip_suspended, skip_st, fields):
        return cls.__request("get_instruments",
                             {"exchanges": exchanges, "sec_types": sec_types, "skip_suspended": skip_suspended,
                              "skip_st": skip_st, "fields": fields})

    @classmethod
    def get_previous_trading_date(cls, exchange, date):
        return cls.__request("get_previous_trading_date", {"exchange": exchange, "date": date})

    @classmethod
    def get_next_trading_date(cls, exchange, date):
        return cls.__request("get_next_trading_date", {"exchange": exchange, "date": date})

    @classmethod
    def get_trading_dates(cls, exchange, start_date, end_date):
        return cls.__request("get_trading_dates",
                             {"exchange": exchange, "start_date": start_date, "end_date": end_date})


class JueJinApi:
@@ -15,10 +103,13 @@
    @classmethod
    def getJueJinAccountInfo(cls):
        redis = cls.__redisManager.getRedis()
        account_id = redis.get("juejin-account-id")
        strategy_id = redis.get("juejin-strategy-id")
        token = redis.get("juejin-token")
        return account_id, strategy_id, token
        try:
            account_id = RedisUtils.get(redis, "juejin-account-id", auto_free=False)
            strategy_id = RedisUtils.get(redis, "juejin-strategy-id", auto_free=False)
            token = RedisUtils.get(redis, "juejin-token", auto_free=False)
            return account_id, strategy_id, token
        finally:
            RedisUtils.realse(redis)

    @classmethod
    def get_juejin_code_list_with_prefix(cls, codes):
@@ -34,56 +125,88 @@
    def get_gp_latest_info(cls, codes, fields=None):
        if not codes:
            return []
        account_id, s_id, token = cls.getJueJinAccountInfo()
        symbols = cls.get_juejin_code_list_with_prefix(codes)
        gmapi.set_token(token)
        data = gmapi.get_instruments(symbols=",".join(symbols), fields=fields)
        print(data)
        return data
        if constant.JUEJIN_LOCAL_API:
            account_id, s_id, token = cls.getJueJinAccountInfo()
            gmapi.set_token(token)
            data = gmapi.get_instruments(symbols=",".join(symbols), fields=fields)
            return data
        else:
            return JueJinHttpApi.get_instruments(symbols=",".join(symbols), fields=fields)

    @classmethod
    def get_history_tick_n(cls, code, count, fields=None):
        account_id, s_id, token = cls.getJueJinAccountInfo()
        symbols = cls.get_juejin_code_list_with_prefix([code])
        gmapi.set_token(token)
        # 前除权
        results = gmapi.history_n(symbol=symbols[0], frequency="1d", count=count, adjust=1, fields=fields)
        return results
        if constant.JUEJIN_LOCAL_API:
            account_id, s_id, token = cls.getJueJinAccountInfo()
            gmapi.set_token(token)
            # 前除权
            results = gmapi.history_n(symbol=symbols[0], frequency="1d", count=count, adjust=1, fields=fields)
            return results
        else:
            results = JueJinHttpApi.history_n(symbol=symbols[0], frequency="1d", count=count, adjust=1, fields=fields)
            return results

    @classmethod
    def get_gp_current_info(cls, codes):
        if not codes:
            return []
        account_id, s_id, token = cls.getJueJinAccountInfo()
        symbols = cls.get_juejin_code_list_with_prefix(codes)
        gmapi.set_token(token)
        data = gmapi.current(symbols=",".join(symbols))
        print(data)
        return data

        if constant.JUEJIN_LOCAL_API:
            account_id, s_id, token = cls.getJueJinAccountInfo()
            gmapi.set_token(token)
            data = gmapi.current(symbols=",".join(symbols))
            return data
        else:
            data = JueJinHttpApi.current(symbols=",".join(symbols), fields='')
            return data
        # 返回指定日期的上个交易日

    # 获取交易所的代码
    @classmethod
    def get_exchanges_codes(cls, exchanges):
        if constant.JUEJIN_LOCAL_API:
            account_id, s_id, token = cls.getJueJinAccountInfo()
            gmapi.set_token(token)
            return gmapi.get_instruments(exchanges=exchanges, sec_types=[1], skip_suspended=True, skip_st=True,
                                         fields="symbol,sec_type,sec_id,sec_name,listed_date,sec_level,is_suspended,pre_close")
        else:
            return JueJinHttpApi.get_exchanges_codes(exchanges=exchanges, sec_types=[1], skip_suspended=True,
                                                     skip_st=True,
                                                     fields="symbol,sec_type,sec_id,sec_name,listed_date,sec_level,is_suspended,pre_close")

    @classmethod
    def get_previous_trading_date(cls, date):
        account_id, s_id, token = cls.getJueJinAccountInfo()
        gmapi.set_token(token)
        return gmapi.get_previous_trading_date("SHSE", date)
        if constant.JUEJIN_LOCAL_API:
            account_id, s_id, token = cls.getJueJinAccountInfo()
            gmapi.set_token(token)
            return gmapi.get_previous_trading_date("SHSE", date)
        else:
            return JueJinHttpApi.get_previous_trading_date("SHSE", date)

    # 返回指定日期的下个交易日
    @classmethod
    def get_next_trading_date(cls, date):
        account_id, s_id, token = cls.getJueJinAccountInfo()
        gmapi.set_token(token)
        return gmapi.get_previous_trading_date("SHSE", date)
        if constant.JUEJIN_LOCAL_API:
            account_id, s_id, token = cls.getJueJinAccountInfo()
            gmapi.set_token(token)
            return gmapi.get_next_trading_date("SHSE", date)
        else:
            return JueJinHttpApi.get_next_trading_date("SHSE", date)

    @classmethod
    def get_trading_dates(cls, start_date, end_date):
        account_id, s_id, token = cls.getJueJinAccountInfo()
        gmapi.set_token(token)
        return gmapi.get_trading_dates("SHSE", start_date, end_date)
        if constant.JUEJIN_LOCAL_API:
            account_id, s_id, token = cls.getJueJinAccountInfo()
            gmapi.set_token(token)
            return gmapi.get_trading_dates("SHSE", start_date, end_date)
        else:
            return JueJinHttpApi.get_trading_dates("SHSE", start_date, end_date)


class HistoryKDatasUtils(object):
    __previous_trading_date_cache = {}
    __latest_trading_date_cache = {}

    @classmethod
    def get_gp_latest_info(cls, codes, fields=None):
@@ -101,6 +224,35 @@
    @classmethod
    def get_previous_trading_date(cls, date):
        return JueJinApi.get_previous_trading_date(date)

    @classmethod
    def get_previous_trading_date_cache(cls, date):
        if date in cls.__previous_trading_date_cache:
            return cls.__previous_trading_date_cache.get(date)
        fdata = cls.get_previous_trading_date(date)
        if fdata:
            cls.__previous_trading_date_cache[date] = fdata
        return fdata

    # 获取最近的交易日
    @classmethod
    def get_latest_trading_date(cls, day_count):
        now_day = tool.get_now_date_str()
        days = []
        for i in range(day_count):
            pday = cls.get_previous_trading_date_cache(now_day)
            days.append(pday)
            now_day = pday
        return days

    @classmethod
    def get_latest_trading_date_cache(cls, day_count):
        key = f"{tool.get_now_date_str()}-{day_count}"
        if key in cls.__latest_trading_date_cache:
            return cls.__latest_trading_date_cache[key]
        days = cls.get_latest_trading_date(day_count)
        cls.__latest_trading_date_cache[key] = days
        return days

    # 返回指定日期的下个交易日
    @classmethod
@@ -161,3 +313,8 @@
            code_name = data['sec_name']
            results[code] = code_name
        return results


if __name__ == "__main__":
    results = HistoryKDatasUtils.get_codes_limit_rate(list({"000422", "600610"}))
    print(results)