首板买入策略分值优化

Administrator

2023-03-29 8ddc7f5ecc67c0bb424954a86b75ec7444080ba2

首板买入策略分值优化

 data_export_util.py

@@ -196,6 +196,6 @@


if __name__ == "__main__":
    codes = ["002717"]
    codes = ["600573"]
    for code in codes:
        export_l2_excel(code)

 juejin.py

@@ -536,11 +536,25 @@
        keys = redis.keys("juejin_listen_code-*")
        return len(keys)

    # 返回指定日期的上个交易日
    @classmethod
    def get_previous_trading_date(cls, date):
        account_id, s_id, token = getAccountInfo()
        gmapi.set_token(token)
        return gmapi.get_previous_trading_date("SHSE", date)

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

    @classmethod
    def get_trading_dates(cls, start_date, end_date):
        account_id, s_id, token = getAccountInfo()
        gmapi.set_token(token)
        return gmapi.get_trading_dates("SHSE", start_date, end_date)


def trade(code, volume):
@@ -668,7 +682,4 @@


if __name__ == '__main__':
    # datas = (get_volumns_by_code("603083", 150))
    # print(datas)
    # print(get_limit_up_money_percent(datas))
    everyday_init()
    print(JueJinManager.get_trading_dates("2023-03-01", "2023-03-29"))

 l2/l2_data_manager_new.py

@@ -23,7 +23,8 @@
from l2.l2_data_manager import L2DataException, TradePointManager
from l2.l2_data_util import local_today_datas, L2DataUtil, load_l2_data, local_today_num_operate_map, local_latest_datas
import l2.l2_data_util
from log import logger_l2_trade, logger_l2_trade_cancel, logger_l2_trade_buy, logger_l2_process, logger_l2_error,logger_buy_score
from log import logger_l2_trade, logger_l2_trade_cancel, logger_l2_trade_buy, logger_l2_process, logger_l2_error, \
    logger_buy_score

# TODO l2数据管理
from trade.trade_data_manager import CodeActualPriceProcessor
@@ -161,6 +162,7 @@
    __thsBuy1VolumnManager = trade_queue_manager.THSBuy1VolumnManager()
    __buyL2SafeCountManager = safe_count_manager.BuyL2SafeCountManager()
    __l2PlaceOrderParamsManagerDict = {}
    __last_buy_single_dict = {}

    @classmethod
    # 数据处理入口
@@ -235,7 +237,7 @@
            limit_up_time = limit_up_time_manager.get_limit_up_time(code)
            if limit_up_time is None:
                limit_up_time = tool.get_now_time_str()
            score = first_code_score_manager.get_score(code, volume_rate, limit_up_time,True)
            score = first_code_score_manager.get_score(code, volume_rate, limit_up_time, True)
            cls.__l2PlaceOrderParamsManagerDict[code] = l2_trade_factor.L2PlaceOrderParamsManager(code, is_first_code,
                                                                                                  volume_rate,
                                                                                                  volume_rate_index,
@@ -449,7 +451,7 @@
    @classmethod
    def __buy(cls, code, capture_timestamp, last_data, last_data_index, is_first_code):
        __start_time = tool.get_now_timestamp()
        can, need_clear_data, reason = False,False,""
        can, need_clear_data, reason = False, False, ""
        if not is_first_code:
            can, need_clear_data, reason = cls.__can_buy(code)
        else:
@@ -522,16 +524,18 @@
    @classmethod
    def __can_buy(cls, code):
        __start_time = t.time()
            # 之前的代码
            # 首板代码且尚未涨停过的不能下单
            # is_limited_up = gpcode_manager.FirstCodeManager.is_limited_up(code)
            # if not is_limited_up:
            #     gpcode_manager.FirstCodeManager.add_limited_up_record([code])
            #     place_order_count = trade_data_manager.placeordercountmanager.get_place_order_count(
            #         code)
            #     if place_order_count == 0:
            #         trade_data_manager.placeordercountmanager.place_order(code)
            #     return False, True, "首板代码，且尚未涨停过"
        if not trade_manager.TradeStateManager.is_can_buy():
            return False, True, f"今日已禁止交易"
        # 之前的代码
        # 首板代码且尚未涨停过的不能下单
        # is_limited_up = gpcode_manager.FirstCodeManager.is_limited_up(code)
        # if not is_limited_up:
        #     gpcode_manager.FirstCodeManager.add_limited_up_record([code])
        #     place_order_count = trade_data_manager.placeordercountmanager.get_place_order_count(
        #         code)
        #     if place_order_count == 0:
        #         trade_data_manager.placeordercountmanager.place_order(code)
        #     return False, True, "首板代码，且尚未涨停过"

        try:
            # 买1价格必须为涨停价才能买
@@ -575,12 +579,11 @@
            if volumn_rate >= 1.3:
                return False, False, "最大量比超过1.3不能买"


            limit_up_time = limit_up_time_manager.get_limit_up_time(code)
            if limit_up_time is not None:
                limit_up_time_seconds = l2.l2_data_util.L2DataUtil.get_time_as_second(
                    limit_up_time)
                if  limit_up_time_seconds >= l2.l2_data_util.L2DataUtil.get_time_as_second(
                if limit_up_time_seconds >= l2.l2_data_util.L2DataUtil.get_time_as_second(
                        "13:00:00"):
                    return False, False, "二板下午涨停的不能买，涨停时间为{}".format(limit_up_time)
                if limit_up_time_seconds >= l2.l2_data_util.L2DataUtil.get_time_as_second("14:55:00"):
@@ -648,6 +651,8 @@

    @classmethod
    def __can_buy_first(cls, code):
        if not trade_manager.TradeStateManager.is_can_buy():
            return False, True, f"今日已禁止交易"

        if not gpcode_manager.WantBuyCodesManager.is_in(code):
            # 查看分数等级
@@ -655,8 +660,8 @@
            score = cls.__l2PlaceOrderParamsManagerDict[code].score
            if score_index < 0:
                return False, True, f"分值：{score}未达到需要买入的分数线"
            # if -1 < score_index < 3:
            #     return True, False, f"分值：{score}达到主动买入的分数线，买入等级：f{score_index}"
            # if -1 < score_index < 3 and (0.499 <= cls.volume_rate_info[code][0] <= 0.949):
            #     return True, False, f"分值：{score}达到主动买入的分数线且量足够，买入等级：f{score_index},量比：{cls.volume_rate_info[code][0]}"
            is_limited_up = gpcode_manager.FirstCodeManager.is_limited_up(code)
            gpcode_manager.FirstCodeManager.add_limited_up_record([code])
            if not code_price_manager.Buy1PriceManager.is_can_buy(code):
@@ -739,8 +744,14 @@
            has_single, _index = cls.__compute_order_begin_pos(code, max(
                (compute_start_index - continue_count - 1) if new_add else compute_start_index, 0), continue_count,
                                                               compute_end_index)
            # 如果买入信号与上次的买入信号一样就不能算新的信号
            if cls.__last_buy_single_dict.get(code) == _index:
                has_single = None
                _index = None

            buy_single_index = _index
            if has_single:
                cls.__last_buy_single_dict[code] = buy_single_index
                new_get_single = True
                num = 0
                count = 0
@@ -791,8 +802,9 @@
            return

        if compute_index is not None:
            l2_log.debug(code, "获取到买入执行位置：{} m值：{} 纯买手数：{} 纯买单数：{} 数据：{} ,量比:{} ", compute_index, threshold_money, buy_nums,
                         buy_count, total_datas[compute_index],cls.volume_rate_info[code][0])
            l2_log.debug(code, "获取到买入执行位置：{} m值：{} 纯买手数：{} 纯买单数：{} 数据：{} ,量比:{} ", compute_index, threshold_money,
                         buy_nums,
                         buy_count, total_datas[compute_index], cls.volume_rate_info[code][0])

            f1 = dask.delayed(cls.__save_order_begin_data)(code, buy_single_index, compute_index, compute_index,
                                                           buy_nums, buy_count, max_num_set_new,

 log.py

@@ -123,7 +123,7 @@
                   rotation="00:00", compression="zip", enqueue=True)

        logger.add(self.get_path("score", "buy_score"),
                   filter=lambda record: record["extra"].get("name") == "score",
                   filter=lambda record: record["extra"].get("name") == "buy_score",
                   rotation="00:00", compression="zip", enqueue=True)

    def get_path(self, dir_name, log_name):

 output/code_info_output.py

@@ -17,13 +17,14 @@
from third_data import hot_block_data_process
from trade import first_code_score_manager, l2_trade_factor
from trade.l2_trade_factor import L2TradeFactorUtil
import trade.deal_big_money_manager


def __format_data(code_info, score_info, buy_params_info, xgb_code_info, xgb_infos):
    html = ""
    html += f"<h2>{code_info[1]} {code_info[0]}</h2><br>"
    if score_info:
        html += "-----买前评分-------<br>"
        html += "<b>-----买前评分-------</b><br>"
        score_types = ["换手量能", "竞价强度", "资金力度", "日线形态", "历史股性", "板块热度", "上板时间", "市值大小", "股价大小"]
        html += "<table style='font-size:25px'>"
        for i in range(0, len(score_info[1])):
@@ -32,14 +33,14 @@
        html += f"</table>"

    if buy_params_info:
        html += "<br>-----交易参数-------<br><table>"
        html += "<b><br>-----交易参数-------<br></b><table>"
        titles = ["买入意愿", "安全笔数", "动态M值", "买前大单", "成交进度", "买入信号", "买入执行位"]
        for i in range(0, len(titles)):
            html += f"<tr><td>{titles[i]}：</td><td>{buy_params_info[i]}</td></tr>"
        html += "</table>"

    if xgb_code_info:
        html += "<br>-----选股宝---------<br>"
        html += "<b><br>-----选股宝---------<br></b>"
        xgb_code_info_dates = ["今天", "昨天", "前天", "之前"]
        for i in range(0, len(xgb_code_info)):
            html += f"{xgb_code_info_dates[i]}：<br>"
@@ -52,10 +53,11 @@
            else:
                html += f"无<br>"
    if xgb_infos:
        html += "<br>-----市场热度-------<br><table>"
        html += "<b><br>-----市场热度-------<br></b><table>"
        for info in xgb_infos:
            html += f"<tr><td>{info}</td></tr>"
            html += f"<tr><td><font size='3'>{info[0]}</font><br><div style='margin-left:100px;'>{info[1]}</div></td></tr>"
        html += "</tr>"
    html += "<br><br>"
    return html


@@ -81,13 +83,30 @@
        # 获取当前量信息
        max_60, yest = code_volumn_manager.get_histry_volumn(code)
        today = code_volumn_manager.get_today_volumn(code)
        score_source_list_new.append(f"实时量【{round(int(today)/1000000,2)}万手】÷前高量【{round(max_60[0]/1000000,2)}万手-{max_60[1]}】=【{round(score_source_list[6]*100,2)}%】")
        score_source_list_new.append(
            f"实时量【{round(int(today) / 1000000, 2)}万手】÷前高量【{round(max_60[0] / 1000000, 2)}万手-{max_60[1]}】=【{round(score_source_list[6] * 100, 2)}%】")
        # 竞价强度
        score_list_new.append(score_list[2])
        score_source_list_new.append(f"开盘啦今日委停【{score_source_list[2] if score_source_list[2] else 0}万】")
        total_datas = l2_data_util.local_today_datas.get(code)
        if total_datas is None:
            l2_data_util.load_l2_data(code)
            total_datas = l2_data_util.local_today_datas.get(code)
        # 资金力度
        deal_indexes = trade.deal_big_money_manager.get_traded_indexes(code)
        deal_info = ""
        if deal_indexes:
            temps = []
            for index in deal_indexes:
                temps.append(int(index))
            temps.sort()
            start_index = temps[0]
            end_index = temps[-1]
            deal_info = f"【{total_datas[start_index]['val']['time']}&{total_datas[start_index]['val']['num']}手-{total_datas[end_index]['val']['time']}&{total_datas[end_index]['val']['num']}手】,"

        score_list_new.append(score_list[8])
        score_source_list_new.append(f"累计金额【{score_source_list[8][0] // 10000}万】&固定m值【{score_source_list[8][1] // 10000}万】")
        score_source_list_new.append(
            f"{deal_info}<br>累计金额【{score_source_list[8][0] // 10000}万】&固定m值【{score_source_list[8][1] // 10000}万】")
        # K线形态
        k_score = 0
        k_source = []
@@ -172,11 +191,14 @@
        __L2PlaceOrderParamsManager = l2_trade_factor.L2PlaceOrderParamsManager(code, True, volume_rate,
                                                                                code_volumn_manager.get_volume_rate_index(
                                                                                    volume_rate),
                                                                                ((score, score_list),score_source_list))
                                                                                (
                                                                                    (score, score_list),
                                                                                    score_source_list))
        __base_L2PlaceOrderParamsManager = l2_trade_factor.L2PlaceOrderParamsManager(code, False, volume_rate,
                                                                                     code_volumn_manager.get_volume_rate_index(
                                                                                         volume_rate),
                                                                                     ((score, score_list),score_source_list))
                                                                                     ((score, score_list),
                                                                                      score_source_list))
        buy_params_info = []
        if -1 < __L2PlaceOrderParamsManager.score_index < 3:
            buy_params_info.append("<font color='red'>【主动买入】</font>")
@@ -201,10 +223,6 @@
        base_big_num = __base_L2PlaceOrderParamsManager.get_big_num_count()
        buy_params_info.append(f"固定买前大单【{base_big_num}】笔，衰减后买前大单【{big_num}】笔")
        # 成交进度
        total_datas = l2_data_util.local_today_datas.get(code)
        if total_datas is None:
            l2_data_util.load_l2_data(code)
            total_datas = l2_data_util.local_today_datas.get(code)
        trade_progress, is_default = transaction_progress.TradeBuyQueue().get_traded_index(code)
        if trade_progress is None or trade_progress < 0 or is_default:
            buy_params_info.append("未识别")
@@ -267,12 +285,51 @@
    if not xgb_latest_datas:
        xgb_infos.append('暂未获取到数据')
    else:
        # 获取今日的所有数据
        datas_record = hot_block_data_process.XGBHotBlockDataManager.list_all(tool.get_now_date_str())
        datas_record_dict = {}
        for data in datas_record:
            block = data[2]
            if block not in datas_record_dict:
                datas_record_dict[block] = []
            # 代码,代码名称,涨停时间，首次涨停时间
            datas_record_dict[block].append((data[3], data[9], data[4], data[8], block))

        for block in xgb_latest_datas:
            limit_up_count = 0
            codes = datas_record_dict.get(block[0])
            for code_data in block[2]:
                if len(code_data[4]) > 6:
                    limit_up_count += 1
            xgb_infos.append(f"【{block[0]}】，涨幅【{block[1]}】，共【{limit_up_count}】个涨停")
            # 获取板块中的代码
            block_codes_set = set()
            for d in block[2]:
                code = d[0][1].split(".")[0]
                block_codes_set.add(code)

            if codes:
                codes_data_html = "<table><tr>"
                count = 0
                for code_data in codes:
                    if code_data[4] != block[0]:
                        # 不是该板块数据
                        continue
                    count += 1
                    codes_data_html += "<td>"
                    # 如果代码涨停时间或者没有在最新的代码中
                    if (len(code_data[2]) < 6 or code_data[0] not in block_codes_set) and len(code_data[3]) > 6:
                        # 炸板
                        codes_data_html += f"<font color='#000080'>{code_data[1]}:{code_data[0]}&nbsp;&nbsp;</font>"
                    elif len(code_data[2]) > 6:
                        # 涨停
                        codes_data_html += f"<font color='#FF3232'>{code_data[1]}:{code_data[0]}&nbsp;&nbsp;</font>"
                    else:
                        codes_data_html += f"{code_data[1]}:{code_data[0]}&nbsp;&nbsp;"
                    codes_data_html += "</td>"
                    if count % 4 == 0:
                        codes_data_html += "</tr><tr>"
                codes_data_html += "</tr></table>"
                xgb_infos.append((f"***【{block[0]}】，涨幅【{block[1]}】，共【{limit_up_count}】个涨停", codes_data_html))

    return __format_data(code_info, score_info, buy_params_info, xgb_code_info, xgb_infos)


 server.py

@@ -728,7 +728,7 @@
                # 获取最近2个交易日涨停代码
                elif type == 72:
                    day = tool.get_now_date_str()
                    data_dict={}
                    data_dict = {}
                    for i in range(0, 2):
                        day = juejin.JueJinManager.get_previous_trading_date(day)
                        data_list = list(hot_block_data_process.XGBHotBlockDataManager.list_all(day))
@@ -818,6 +818,14 @@
                        name = gpcode_manager.get_code_name(code)
                        datas.append(f"{name}:{code}")
                    return_str = json.dumps({"code": 0, "data": datas})
                elif type == 501:
                    data = json.loads(_str)
                    is_open = data["data"]["open"]
                    if is_open:
                        trade_manager.TradeStateManager.open_buy()
                    else:
                        trade_manager.TradeStateManager.close_buy()
                    return_str = json.dumps({"code": 0, "msg": ("开启成功" if is_open else "关闭成功")})

                sk.send(return_str.encode())

@@ -908,24 +916,22 @@
    print(cid, pid)

if __name__ == "__main__":
    codes = ["603655"]
    codes = ["000719"]
    for code in codes:
        try:
            global_data_loader.load_zyltgb()
            limit_up_price = float(gpcode_manager.get_limit_up_price(code))
            limit_up_price = float("11.13")  # float(gpcode_manager.get_limit_up_price(code))
            volumes_data = juejin.get_volumns_by_code(code, 150)
            volumes_data = volumes_data[1:]
            volumes = juejin.parse_max_volume(volumes_data[:60],
                                              code_nature_analyse.is_new_top(gpcode_manager.get_limit_up_price(code),
                                              code_nature_analyse.is_new_top(limit_up_price,
                                                                             volumes_data[:60]))
            logger_first_code_record.info("{} 获取到首板60天最大量：{}", code, volumes)
            code_volumn_manager.set_histry_volumn(code, volumes[0], volumes[1], volumes[2])
            # 判断K线形态
            is_has_k_format, msg = code_nature_analyse.is_has_k_format(
                gpcode_manager.get_limit_up_price(code), volumes_data)
            if not is_has_k_format:
                logger_first_code_record.info("{}首板K线形态不好,{}", code, msg)
                # 加入禁止交易代码
                l2_trade_util.forbidden_trade(code)
            k_format = code_nature_analyse.get_k_format(
                limit_up_price, volumes_data)
            print(k_format)

            code_nature_analyse.set_record_datas(code,
                                                 gpcode_manager.get_limit_up_price(code),

 third_data/hot_block.py

@@ -12,6 +12,7 @@


def __parseData(driver):
    time_ele = driver.find_element(by=By.TAG_NAME, value="time")
    date_element = \
        driver.find_element(by=By.ID, value="nuxt-layout-container").find_elements(by=By.TAG_NAME, value="time")[0]
    date_elements = date_element.find_elements(by=By.TAG_NAME, value="span")
@@ -42,6 +43,7 @@
        codes_list = []
        for content in contents:
            tds = content.find_elements(by=By.TAG_NAME, value="td")
            code_name = tds[0].find_elements(by=By.TAG_NAME, value="span")[0].text
            code = tds[0].find_elements(by=By.TAG_NAME, value="span")[1].text
            limit_up_info = tds[1].text
            price = tds[2].text
@@ -49,7 +51,7 @@
            limit_up_time = tds[4].text
            huanshou = tds[5].text
            ltsz = tds[6].text
            codes_list.append((code, limit_up_info, price, rate, limit_up_time, huanshou, ltsz))
            codes_list.append(((code_name, code), limit_up_info, price, rate, limit_up_time, huanshou, ltsz))
        data_list.append((title, total_rate, codes_list))
        print("----------------------")

@@ -68,10 +70,13 @@
    time.sleep(5)
    while True:
        time.sleep(3)
        # 交易时间才识别
        time_str = datetime.datetime.now().strftime("%H%M%S")
        # 交易时间才识别
        # if int(time_str) < int("092500") or int(time_str) > int("150000"):
        #     continue
        # 每天9点25到9点26刷新
        if int("092500") < int(time_str) < int("092700"):
            driver.refresh()
        # if int("113000") < int(time_str) < int("130000"):
        #     continue
        try:

 third_data/hot_block_data_process.py

@@ -1,8 +1,10 @@
"""
热门板块数据处理
"""
import datetime
import json

import juejin
import tool
from db import redis_manager
from db import mysql_data
@@ -29,14 +31,14 @@
        code_block_dict = {}
        for data in datas:
            for code_info in data[2]:
                code = code_info[0].split(".")[0]
                code = code_info[0][1].split(".")[0]
                if not code_block_dict.get(code):
                    code_block_dict[code] = set()
                code_block_dict[code].add(data[0])

        for data in datas:
            for code_info in data[2]:
                code = code_info[0].split(".")[0]
                code = code_info[0][1].split(".")[0]
                _id = f"{day}_{data[0]}_{code}"

                result = mysqldb.select_one("select * from xgb_hot_block where _id='{}'".format(_id))
@@ -45,12 +47,12 @@
                    limit_up_time = ''
                if not result:
                    mysqldb.execute(
                        f"insert into xgb_hot_block(_id,_day,_block_name,_code,_limit_up_time,_price,_rate,_update_time,_first_limit_up_time) values('{_id}','{day}','{data[0]}','{code}','{code_info[4]}','{code_info[2]}','{code_info[3]}',now(),'{limit_up_time}')")
                        f"insert into xgb_hot_block(_id,_day,_block_name,_code,_limit_up_time,_price,_rate,_update_time,_first_limit_up_time,_code_name) values('{_id}','{day}','{data[0]}','{code}','{code_info[4]}','{code_info[2]}','{code_info[3]}',now(),'{limit_up_time}','{code_info[0][0]}')")
                else:
                    # 如果上次的数据和这次一样就不更新，否则需要更新数据
                    if cls.__last_datas.get(_id) != code_info:
                        mysqldb.execute(
                            f"update xgb_hot_block set _limit_up_time='{code_info[4]}',_price='{code_info[2]}',_rate='{code_info[3]}',_update_time=now() where _id='{_id}'")
                            f"update xgb_hot_block set _limit_up_time='{code_info[4]}',_price='{code_info[2]}',_rate='{code_info[3]}',_update_time=now(),_code_name='{code_info[0][0]}' where _id='{_id}'")
                        if (not result[8] or len(result[8]) <= 6) and len(limit_up_time) >= 6:
                            mysqldb.execute(
                                f"update xgb_hot_block set _first_limit_up_time='{limit_up_time}',_update_time=now() where _id='{_id}'")
@@ -80,10 +82,61 @@
        mysqldb = mysql_data.Mysqldb()
        return mysqldb.select_all(f"select * from xgb_hot_block where _block_name='{block_name}' and _day='{day}'")

    @staticmethod
    def list_blocks(days):
        mysqldb = mysql_data.Mysqldb()
        sql = "select distinct(_block_name) from xgb_hot_block where "
        wheres = []
        for day in days:
            wheres.append(f"_day = '{day}'")
        sql += " or ".join(wheres)
        results = mysqldb.select_all(sql)
        fresult = set()
        for result in results:
            fresult.add(result[0])
        return fresult


__blocks_dict = {}


def get_latest_block(day_count=15):
    now_day = tool.get_now_date_str()
    if now_day in __blocks_dict:
        return __blocks_dict[now_day]
    now_date = datetime.datetime.now()
    end_date = juejin.JueJinManager.get_previous_trading_date(tool.get_now_date_str())
    start_date = now_date - datetime.timedelta(days=(day_count * 2 + 10))
    start_date = start_date.strftime("%Y-%m-%d")
    days = juejin.JueJinManager.get_trading_dates(start_date, end_date)
    days = days[0 - day_count:]
    results = XGBHotBlockDataManager.list_blocks(days)
    __blocks_dict[now_day] = results
    return results


# 获取代码所在板块信息
def get_info(code):
    blocks = get_code_blocks(code)
    # 判断是否有新概念
    # 新概念
    new_block = None
    latest_blocks = get_latest_block(15)
    for block in blocks:
        if block not in latest_blocks:
            new_block = block
            # 如果板块中的涨停票数》=2才算新题材
            count = 0
            if XGBHotBlockDataManager.latest_datas:
                for b in XGBHotBlockDataManager.latest_datas:
                    if b[0] == new_block:
                        for code_data in b[2]:
                            if len(code_data[4]) > 6:
                                count += 0
            if count < 2:
                new_block = None
            if not new_block:
                break

    target_block = None
    if blocks:
@@ -101,7 +154,7 @@
            if block[0] == target_block:
                for code_data in block[2]:
                    if len(code_data[4]) > 6:
                        limit_up_codes_set.add(code_data[0].split('.')[0])
                        limit_up_codes_set.add(code_data[0][1].split('.')[0])
    limit_up_codes_set.discard(code)
    limit_up_count = len(limit_up_codes_set)

@@ -122,7 +175,7 @@
    break_codes = break_codes.difference(limit_up_codes_set)
    # 炸板个数
    break_size = len(break_codes)
    return target_block, limit_up_count, break_size
    return target_block, limit_up_count, break_size, new_block


# 保存数据
@@ -133,7 +186,7 @@
    for block in datas:
        codes = []
        for code_data in block[2]:
            code = code_data[0].split(".")[0]
            code = code_data[0][1].split(".")[0]
            if gpcode_manager.FirstCodeManager.is_in_first_record(code):
                limit_up_time = code_data[4]
                if limit_up_time and len(limit_up_time) > 6:
@@ -185,5 +238,5 @@
if __name__ == "__main__":
    # XGBHotBlockDataManager.total_datas=XGBHotBlockDataManager.list_all("2023-03-23")
    # get_info('002230')
    codes = set([1, 2, 3, 4])
    print(codes.difference(set([1, 2])))
    print(get_latest_block())
    print(get_latest_block())

 trade/first_code_score_manager.py

@@ -5,7 +5,7 @@
# bidding 是否满足竞价
# deal_big_money 成交大金额是否满足
# code_nature = (是否有涨停，是否有溢价)
# hot_block(板块中涨停票个数（包含自己），板块炸板票个数)
# hot_block(板块中涨停票个数（包含自己），板块炸板票个数, 新板块名称)
# zyltgb自由流通市值是否大于250亿
# limit_price 涨停价是否大于100块
# limit_up_time 是否10点之前涨停
@@ -24,7 +24,7 @@
    score_list = []
    if zyltgb:
        zyltgbs = [0, 10, 31, 51, 101, 150, 250, 1000000]
        zyltgb_score = [20, 30, 20, 10, 0, -10, -20]
        zyltgb_score = [20, 30, 20, 10, -1000, -1000, -1000]
        for i in range(1, len(zyltgbs)):
            if zyltgbs[i - 1] <= zyltgb / 100000000 < zyltgbs[i]:
                score_list.append(zyltgb_score[i - 1])
@@ -45,34 +45,34 @@
    k_score = []
    # 15个交易日是否涨幅24.9%
    if k_form[0]:
        k_score.append(-55)
        k_score.append(-1000)
    else:
        k_score.append(0)

    # 是否破前高
    if k_form[1]:
        k_score.append(65)
        k_score.append(55)
    else:
        k_score.append(0)
    # 是否超跌
    if k_form[2]:
        k_score.append(45)
        k_score.append(35)
    else:
        k_score.append(0)

    # 是否接近前高
    if k_form[3]:
        k_score.append(-25)
        k_score.append(-35)
    else:
        k_score.append(0)
    # 是否N
    if k_form[4]:
        k_score.append(40)
        k_score.append(30)
    else:
        k_score.append(0)
    # 是否V
    if k_form[5]:
        k_score.append(35)
        k_score.append(25)
    else:
        k_score.append(0)

@@ -80,7 +80,7 @@
    if k_form[6]:
        k_score.append(0)
    else:
        k_score.append(-25)
        k_score.append(-35)

    score_list.append(k_score)

@@ -103,15 +103,18 @@
    hot_block_score = []
    # 板块中只有自己涨停，且无炸板
    if hot_block[1] == 1 and hot_block[2] == 0:
        hot_block_score.append(25)
        hot_block_score.append(20)
    elif hot_block[1] >= 2 and hot_block[2] == 0:
        hot_block_score.append(35)
        hot_block_score.append(30)
    elif hot_block[3] and not k_form[6]:
        # 有新题材，且没有K线形态
        hot_block_score.append(30)
    else:
        hot_block_score.append(5)
        hot_block_score.append(0)
    score_list.append(hot_block_score)

    # 量
    volume_score = [0, 35, 45, 55, 45, 35, 15, -5, -30]
    volume_score = [0, 40, 50, 60, 50, 40, 20, 0, -25]
    volume_rates = [0, 0.349, 0.499, 0.649, 0.799, 0.949, 1.099, 1.249, 1.399]
    volume_add = False
    for i in range(1, len(volume_rates)):
@@ -124,7 +127,7 @@

    if limit_up_time:
        times = ["10:00:00", "11:30:00", "14:00:00", "15:00:00"]
        time_scores = [15, 10, 5, 0]
        time_scores = [5, 4, 3, 2]
        for i in range(0, len(times)):
            if int(times[i].replace(":", "")) >= int(limit_up_time.replace(":", "")):
                score_list.append(time_scores[i])
@@ -134,7 +137,7 @@

        # 大单成交
    if deal_big_money:
        score_list.append(30)
        score_list.append(35)
    else:
        score_list.append(0)

@@ -180,10 +183,10 @@

    hot_block = hot_block_data_process.get_info(code)
    if hot_block is None:
        hot_block = ('无板块', 1, 0)
        hot_block = ('无板块', 1, 0, None)
    else:
        # 加上自己
        hot_block = (hot_block[0], hot_block[1] + 1, hot_block[2])
        hot_block = (hot_block[0], hot_block[1] + 1, hot_block[2], hot_block[3])

    source_datas.append(hot_block)


 trade/l2_trade_factor.py

@@ -76,7 +76,7 @@
    def get_safe_count(self):
        if self.is_first_code:
            if 3 > self.score_index > -1:
                return 0
                return 2
            elif self.score_index < 0:
                return 65535
        base_count, min_count, max_count = L2TradeFactorUtil.get_safe_buy_count(self.code, True)

 trade/trade_manager.py

@@ -35,6 +35,38 @@
latest_trade_delegate_data = []


# 关闭购买入口
# 开启购买入口
class TradeStateManager:
    redisManager = redis_manager.RedisManager(2)

    @classmethod
    def __get_redis(cls):
        return cls.redisManager.getRedis()

    # 开启购买入口
    @classmethod
    def open_buy(cls):
        cls.__get_redis().setex("trade_buy_state", tool.get_expire(), 1)

    # 关闭购买入口
    @classmethod
    def close_buy(cls):
        cls.__get_redis().setex("trade_buy_state", tool.get_expire(), 0)

    # 是否可以下单
    @classmethod
    def is_can_buy(cls):
        # 默认设置为可交易
        val = cls.__get_redis().get("trade_buy_state")
        if val is None:
            return True
        if int(val) == 1:
            return True
        else:
            return False


# 获取交易状态
def get_trade_state(code):
    redis = __redis_manager.getRedis()