交易设置及接口

admin

2025-03-20 56897a24b0b9b63d62d8df3d11bbae66fe66b1fe

交易设置及接口

 constant.py

@@ -72,6 +72,8 @@

# K线路径
K_BARS_PATH = f"{DATA_DIR_PATH}/all_stocks_all_K_line_property_dict.json"
# 指数K线路径
INDEX_K_BARS_PATH = f"{DATA_DIR_PATH}/all_index_k_line_property_dict.json"
# 每日涨停概念记录数据
KPL_LIMIT_UP_DATA_PATH = f"{DATA_DIR_PATH}/limit_up_block_date_data.jsonl"
# 日内所有股票开盘数据存储  [只是在初步编写时测试使用]

 log_module/log.py

@@ -303,12 +303,16 @@
                   filter=lambda record: record["extra"].get("name") == "local_huaxin_l2_buy_no",
                   rotation="00:00", compression="zip", enqueue=True)

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

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

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

    def get_path(self, dir_name, log_name):
@@ -434,7 +438,9 @@
logger_local_huaxin_trade_debug = __mylogger.get_logger("local_huaxin_trade_debug")
logger_local_huaxin_l1 = __mylogger.get_logger("local_huaxin_l1_show_info")

# -------------------------------开盘啦日志---------------------------------
logger_kpl_jingxuan_in = __mylogger.get_logger("kpl_jingxuan_in")
logger_Overall_market_strength_score = __mylogger.get_logger("Overall_market_strength_score")

logger_common = __mylogger.get_logger("common")


 strategy/all_K_line.py

@@ -97,7 +97,7 @@
        results = []
        dates_list = []
        # 查询交易标的基本信息并赋值
        sec_name = data_cache.DataCache().code_name_dict.get(symbol)
        sec_name = data_cache.DataCache().code_name_dict.get(symbol, "default_name")
        # print(f"K_line_sec_name=={sec_name}")
        # 将获取到的公司名称直接 生成字典放到 K线的第一个序列中
        it_K_line[0]['sec_name'] = sec_name
@@ -383,49 +383,6 @@
    except Exception as error:
        print(f"An error occurred while converting the data to JSON: {error}")
    logger.info(f"标的个股历史k线写完了！{tool.get_now_time_str()}")


# 写入主要指数的90天K线
def main_index_k_line_dict_write():
    main_index_base_K_line_dict = main_index_k_line_history.k_line_history_90day()
    # 初始化所有个股的指标K线列表
    main_index_k_line_property_dict = {}
    for i in data_cache.DataCache().main_index_stocks:
        # print(f"i==========={i}")
        i_k_line = main_index_base_K_line_dict[i]  # 获取i的K线
        i_k_line_copy = copy.deepcopy(i_k_line)  # 深拷贝i的K线
        # it_K_line_reversed = list(reversed(i_k_line_copy))  # 开盘啦获取的数据需要反转i的K线
        it_K_line_reversed = list(i_k_line_copy)  # 小辉端的数据不需要反转i的K线
        if not it_K_line_reversed:
            continue
        k_line_history.get_property_limit_mark(it_K_line_reversed, i)  # 给标的的K线更新指标属性 把股票代码同时传给要调用的函数
        index_k_line_property_dict = {i: it_K_line_reversed}  # 添加 更新极限指标属性的K线 字典
        # print(f"index_k_line_property_dict===={index_k_line_property_dict}")
        main_index_base_K_line_dict.update(index_k_line_property_dict)

    # 构造时间格式datetime转化为字符串，以便将K线属性指标转化为json格式写入本地文件
    def convert_datetime(obj):
        if isinstance(obj, datetime.datetime):
            return obj.strftime('%Y-%m-%d %H:%M:%S')  # 转换为字符串
        elif isinstance(obj, dict):
            return {k: convert_datetime(v) for k, v in obj.items()}  # 递归处理字典
        elif isinstance(obj, list):
            return [convert_datetime(element) for element in obj]  # 递归处理列表
        # 可以添加其他类型的处理逻辑
        else:
            # 对于未知类型，你可以选择保留原样、跳过或引发异常
            # 这里我们选择保留原样
            return obj

    try:
        json_data = json.dumps(convert_datetime(main_index_k_line_property_dict), ensure_ascii=False, indent=4)
        # 将转换后的JSON字符串写入文件
        with open(constant.K_BARS_PATH, 'w', encoding='utf-8') as f:
            f.write(json_data)
    except Exception as error:
        print(f"An error occurred while converting the data to JSON: {error}")
    logger.info(f"主要指数的历史k线写完了！{tool.get_now_time_str()}")



# 用开盘啦数据检测昨日的K线中涨停属性是否有误（盘尾 集合竞价 炸开一个卖一档，但涨幅未变的）

 strategy/data_cache.py

@@ -225,6 +225,8 @@
# {"code":(代码,昨日收盘价,最新价,总成交量,总成交额,买五档（价格，成交额），卖五档（价格，成交额）,更新时间)}
latest_code_market_info_dict = {}

# 主要指数 掘金代码 列表：[上证指数，深证成指，创业扳指，沪深300]
INDEX_SYMBOL_LIST = ['SHSE.000001', 'SZSE.399001', 'SZSE.399006', 'SHSE.000300']
# 股票指数字典 例如：{"000001":（指数, 量, 额, 昨日收盘价）}
stock_index_dict = {}
# 上证指数 瞬时涨幅

 strategy/index_market_trend_strategy.py

@@ -1,9 +1,12 @@
"""
该模块下进行指数行情策略的编写
"""
import copy
# import decimal
import datetime
import json

import constant
from log_module.log import logger_common
# import time
# 引入掘金API
@@ -13,7 +16,8 @@

# import account_management
from strategy import order_methods
from utils import tool
from strategy.all_K_line import k_line_history
from utils import tool, juejin_api

# 获取logger实例
logger = logger_common
@@ -142,4 +146,259 @@
    return index_trend_expectation_score


# 获取指数K线并写入本地的函数
def get_index_K_line():
    all_index_K_line_dict = {}
    for i in data_cache.INDEX_SYMBOL_LIST:
        index_K_line = juejin_api.JueJinApi.history_n(i, "1d", 90, 1, "open,close,high,low,amount,volume,bob")
        # print(f"index_K_line=={index_K_line}")
        all_index_K_line_dict[i] = index_K_line
    # print(f"all_index_K_line=={all_index_K_line_dict}")
    return all_index_K_line_dict


# 给指数K线加入属性值
def get_property_mark(it_K_line, symbol):
    historical_high_price = 0.01  # 初始化历史最高价
    historical_low_price = 0.01  # 初始化历史最低价
    historical_low_price_index = 0  # 初始化历史最高价序号
    historical_high_price_index = 0  # 初始化历史最低价序号
    historical_average_price = 0.01  # 初始化历史均价
    large_amplitude_day = []  # 初始化大幅震荡日期
    current_count = 0  # 当前连续满足条件的天数
    start = None
    results = []
    dates_list = []

    for i in range(0, len(it_K_line) - 1):
        previous_close = it_K_line[i + 1]['close']  # 昨日收盘价
        previous_high = it_K_line[i + 1]['high']  # 昨日最高价
        current_open = round(it_K_line[i]['open'], 2)  # 当日开盘价
        current_close = round(it_K_line[i]['close'], 2)  # 当日收盘价
        current_high = round(it_K_line[i]['high'], 2)  # 当日最高价
        current_low = round(it_K_line[i]['low'], 2)  # 当日最低价
        limit_up_price = basic_methods.limit_up_price(previous_close)  # 计算出的当天涨停价
        limit_up_price = float(limit_up_price)  # 将涨停价转化为浮点
        limit_down_price = basic_methods.limit_down_price(previous_close)  # 计算出的当天跌停价
        limit_down_price = float(limit_down_price)  # 将跌停价转化为浮点
        current_today_volume = it_K_line[i]['volume']  # 当日总交易量
        current_yesterday_volume = it_K_line[i + 1]['volume']  # 昨日总交易量
        # current_today_amount = it_K_line[i]['amount'] #当日总交易额
        current_today_growth = basic_methods.intraday_growth(current_close, previous_close)  # 计算出当日涨幅
        it_K_line[i]['today_growth'] = current_today_growth  # 将当日涨幅数据添加到字典中对应的日期中
        current_today_amplitude = round((current_high - current_low) / previous_close, 2)  # 计算出当日振幅
        it_K_line[i]['today_amplitude'] = current_today_amplitude  # 将当日振幅数据添加到字典中对应的日期中
        historical_high_price = round(max(i['high'] for i in it_K_line), 2)  # 计算出历史最高价
        historical_high_price_index = max(range(len(it_K_line)), key=lambda ii: it_K_line[ii]['high'])  # 找到最高价的索引
        historical_low_price = round(min(i['low'] for i in it_K_line), 2)  # 计算出历史最低价
        historical_low_price_index = min(range(len(it_K_line)), key=lambda ii: it_K_line[ii]['low'])  # 找到最低价的索引
        historical_average_price = round((historical_high_price + historical_low_price) / 2, 2)  # 计算出历史最均价
        # 把最高价、最高价序号、最低价、最低价序号，添加到K线的昨日字典中
        new_properties = {
            'historical_high_price': historical_high_price,
            'historical_high_price_index': historical_high_price_index,
            'historical_low_price': historical_low_price,
            'historical_low_price_index': historical_low_price_index,
            'historical_average_price': historical_average_price
        }
        it_K_line[0].update(new_properties)

        # 计算大振幅的日期并添加到大振幅日期列表中
        if not (-4 < it_K_line[i]['today_growth'] < 4):
            large_amplitude_day.append(it_K_line[i]['bob'])

        # 判断K线图形风险位置 及 高低时间点
        if historical_low_price_index > historical_high_price_index:
            # 序列小于1是历史最高价  历史长度90，其实还可以根据更长来判断更显程度，历史长度很短的一般认为具有更高风险，而更长的之前有可能有更高的历史高位还比较远
            # 最低价在前
            it_K_line[0]['risk_position'] = 'low_price_ahead'
            '''
            以下部分条件分支由于都是对 it_K_line[0]['risk_position'] 数据进行修改，
            条件判断逻辑有部分重叠，所以应按照逻辑的覆盖面进行先后判断，避免先把大部分过滤掉了。
            所以当前条件分支语句的顺序不要轻易更换。
            # [(historical_high_price / round(it_K_line[0]['close'], 2) < 1.05)的预设值取值范围选择其一：
            # {"均价以上近前高的开盘价":1.05,"接近前高 的跌停价":1.11,"接近前高 的一个炸板加一个跌停的收盘价":1.17,"均价与最高价之间的涨停价":1.21,"均价与最高价之间的价":1.33}
            '''
            # 最高位据昨日较远 且 昨收价距历史均价差距较小 且 整体涨跌幅度较大 且 最高位 与 最低位为三倍涨幅的妖股【当前二度试探风险】
            if (2 < historical_high_price_index < 15 and len(it_K_line) >= 90) and (
                    (historical_average_price / round(it_K_line[0]['close'], 2)) < 2) and (
                    historical_high_price > historical_low_price * 3):
                it_K_line[0]['risk_position'] = 'recent_monster_second_break_risk'
            # 最高位据昨日较远 且 昨收价距历史均价差距较小 且 整体涨跌幅度较大 【当前二度突破风险】
            if (2 < historical_high_price_index < 15 and len(it_K_line) >= 90) and (
                    (historical_average_price / round(it_K_line[0]['close'], 2)) < 1.17) and (
                    historical_high_price > historical_low_price * 1.8):
                it_K_line[0]['risk_position'] = 'recent_second_break_risk'
            # 最高位据昨日较远 且 昨收价距历史最高价差距较小（小于5%，涨幅5%是左右是最容易把低吸骗进去的日内涨幅） 且 整体涨跌幅度较大  【当前二度突破近前高风险】
            # 【双成药业 2024-11-08 这样的二次近前高，实际数值为1.4646...，为安全起见还是设置为1.5】
            if (2 < historical_high_price_index < 15 and len(it_K_line) >= 90) and (
                    historical_high_price / round(it_K_line[0]['close'], 2) < 1.5) and (
                    historical_high_price > historical_low_price * 1.8):
                it_K_line[0]['risk_position'] = 'recent_second_break_near_high_position_risk'
            # 昨日就是最高位 且 整体涨跌幅度较大 【当前高位风险】
            if (historical_high_price_index < 2 and len(it_K_line) >= 90) and (
                    historical_high_price > historical_low_price * 1.8):
                it_K_line[0]['risk_position'] = 'recent_high_position_risk'
        else:
            # 最高价在前
            it_K_line[0]['risk_position'] = 'high_price_ahead'
            # 最低位据昨日较远 且 昨收价距历史均价差距较小 且 整体涨跌幅度较大 【当前二度崩溃风险】
            if (2 < historical_low_price_index < 15 and len(it_K_line) >= 90) and (
                    (historical_average_price / round(it_K_line[0]['close'], 2)) > 1.1):
                it_K_line[0]['risk_position'] = 'recent_second_crash_risk'
            # 昨日就是最低位 且 整体涨跌幅度较大 【当前低位风险】
            if (historical_low_price_index < 2 and len(it_K_line) >= 90) and (
                    historical_high_price > historical_low_price * 1.5):
                it_K_line[0]['risk_position'] = 'recent_low_position_risk'

        # 判断K线图形中连续低涨幅天数及具体序列号并把共识价格均价写入文件【阶段性价格共识位置】
        if 0 < it_K_line[i]['today_amplitude'] < 0.025 and i < 60 and (
                historical_high_price > historical_low_price * 1.5):
            if current_count == 0:
                start = i
            # 如果当前涨幅小于阈值，增加连续天数计数器
            current_count += 1
            # 如果循环复合条件的连续天数达到5天，记录起始索引
            if current_count > 5:
                # 检查 results 是否为空或当前序列不与最后一个序列重叠
                if not results or results[-1][1] < start:
                    if 0.98 < it_K_line[i]['high'] / it_K_line[start]['low'] < 1.02:
                        # 没有重叠，直接添加【其中start为循环到起始序号，i为循环到的结束序号。在实际的日期中要反过来】
                        results.append((start, i))
                        # 算出价格共识区间的均价
                        average_consensus_price = round((it_K_line[i]['high'] + it_K_line[start]['low']) / 2, 2)
                        dates_list.append((
                            it_K_line[start]['bob'].strftime('%Y-%m-%d %H:%M:%S'),
                            it_K_line[i]['bob'].strftime('%Y-%m-%d %H:%M:%S'),
                            average_consensus_price))
                        # if len(dates_list) > 1:  # 如果只需要检测包含多段价格共识区
                        it_K_line[0]['rise_and_fall_is_small_start_and_end_date'] = dates_list
        else:
            # 重置计数器
            current_count = 0
            start = None
        #  确保不会出现除以零的报错
        if current_yesterday_volume == 0:
            current_yesterday_volume = 1
            if round(current_today_volume / current_yesterday_volume, 2) > 1.1:
                # print(f"i=={i} {it_K_line[i]['bob']} {round(current_today_volume/current_yesterday_volume,2)} 【放量】")
                if current_today_growth > 0:
                    it_K_line[i]['today_volume_shape'] = 'increases_up'
                    # print(f"i=={i}  {it_K_line[i]['bob']}   【放量上涨】")
                elif current_today_growth < 0:
                    it_K_line[i]['today_volume_shape'] = 'increases_down'
                    # print(f"i=={i}  {it_K_line[i]['bob']}   【放量下跌】")
                else:
                    it_K_line[i]['today_volume_shape'] = 'increases_balance'
                    # print(f"i=={i}  {it_K_line[i]['bob']}   【放量平收】")

            elif round(current_today_volume / current_yesterday_volume, 2) < 0.9:
                # print(f"i=={i} {it_K_line[i]['bob']} {round(current_today_volume/current_yesterday_volume,2)} 【缩量】")
                if current_today_growth > 0:
                    it_K_line[i]['today_volume_shape'] = 'decreases_up'
                    # print(f"i=={i}  {it_K_line[i]['bob']}   【缩量上涨】")
                elif current_today_growth < 0:
                    it_K_line[i]['today_volume_shape'] = 'decreases_down'
                    # print(f"i=={i}  {it_K_line[i]['bob']}   【缩量下跌】")
                else:
                    it_K_line[i]['today_volume_shape'] = 'decreases_balance'
                    # print(f"i=={i}  {it_K_line[i]['bob']}   【缩量平收】")
        else:
            # print(f"i=={i} {it_K_line[i]['bob']} {round(current_today_volume/current_yesterday_volume,2)} 【平量】")
            if current_today_growth > 0:
                it_K_line[i]['today_volume_shape'] = 'remained_up'
                # print(f"i=={i}  {it_K_line[i]['bob']}   【平量上涨】")
            elif current_today_growth < 0:
                it_K_line[i]['today_volume_shape'] = 'remained_down'
                # print(f"i=={i}  {it_K_line[i]['bob']}   【平量下跌】")
            else:
                it_K_line[i]['today_volume_shape'] = 'remained_balance'
                # print(f"i=={i}  {it_K_line[i]['bob']}   【平量平收】")

        if current_open - previous_close > 0:
            # print(f"i=={i}  {it_K_line[i]['bob']} 成交总量:{today_volume},,,成交总金额:{today_amount}")
            # difference = current_close - previous_close
            if current_close - current_open > 0:
                it_K_line[i]['attribute'] = 'up_up'
                # print(f"i=={i}  {it_K_line[i]['bob']} 高开高走 【昨收价：{previous_close}  收盘价：{current_close}】")
            else:
                it_K_line[i]['attribute'] = 'up_down'
                # print(f"i=={i}  {it_K_line[i]['bob']} 高开低走 【昨收价：{previous_close}  收盘价：{current_close}】")
        else:
            if current_close - current_open > 0:
                it_K_line[i]['attribute'] = 'down_up'
                # print(f"i=={i}  {it_K_line[i]['bob']} 低开高走 【昨收价：{previous_close}  收盘价：{current_close}】")
            else:
                it_K_line[i]['attribute'] = 'down_down'
                # print(f"i=={i}  {it_K_line[i]['bob']} 低开低走 【昨收价：{previous_close}  收盘价：{current_close}】")

    # 将高涨跌幅日期打印出来
    # it_K_line[0]['large_amplitude_day'] = large_amplitude_day

    # 判断K线图形长期振幅 及 当前走势 【根据大振幅天数 反推算出 长期低幅度震荡持平、上涨、下跌的个股写入字典】
    if len(large_amplitude_day) < 1:
        # 长期低幅度震荡
        it_K_line[0]['long_term_amplitude'] = 'low_amplitude_oscillation'
        # it_K_line[0]['large_amplitude_day_len'] = len(large_amplitude_day)
        if (historical_high_price / historical_low_price) < 1.15:
            if 0.99 < (historical_average_price / round(it_K_line[0]['close'], 2)) < 1.09:
                # 长期低幅度震荡持平
                it_K_line[0]['long_term_amplitude'] = 'low_amplitude_oscillation_remains_stable'
        else:
            if (historical_low_price_index > historical_high_price_index) and (
                    historical_high_price_index < 2 and len(it_K_line) > 88):
                # 长期低幅度震荡上涨
                it_K_line[0]['long_term_amplitude'] = 'low_amplitude_oscillation_and_rise'
            elif (historical_low_price_index < historical_high_price_index) and (
                    historical_low_price_index < 2 and len(it_K_line) > 88):
                # 长期低幅度震荡下跌
                it_K_line[0]['long_term_amplitude'] = 'low_amplitude_oscillation_and_decline'

# 将加入属性值的指数K线下入到本地文件中
def all_index_k_line_dict_write():
    all_index_K_line_dict = get_index_K_line()
    # 初始化所有个股的指标K线列表
    all_index_k_line_property_dict = {}
    for i in data_cache.INDEX_SYMBOL_LIST:
        # print(f"i==========={i}")
        i_k_line = all_index_K_line_dict[i]  # 获取i的K线
        i_k_line_copy = copy.deepcopy(i_k_line)  # 深拷贝i的K线
        it_K_line_reversed = list(reversed(i_k_line_copy))  # 开盘啦获取的数据需要反转i的K线
        if not it_K_line_reversed:
            continue
        get_property_mark(it_K_line_reversed, i)  # 给标的的K线更新指标属性 把股票代码同时传给要调用的函数
        symbol_K_line_property_dict = {i: it_K_line_reversed}  # 添加 更新极限指标属性的K线 字典
        # print(f"symbol_K_line_property_dict===={symbol_K_line_property_dict}")
        all_index_k_line_property_dict.update(symbol_K_line_property_dict)
    # print(f"all_index_k_line_property_dict===={all_index_k_line_property_dict}")

    # 构造时间格式datetime转化为字符串，以便将K线属性指标转化为json格式写入本地文件
    def convert_datetime(obj):
        if isinstance(obj, datetime.datetime):
            return obj.strftime('%Y-%m-%d %H:%M:%S')  # 转换为字符串
        elif isinstance(obj, dict):
            return {k: convert_datetime(v) for k, v in obj.items()}  # 递归处理字典
        elif isinstance(obj, list):
            return [convert_datetime(element) for element in obj]  # 递归处理列表
        # 可以添加其他类型的处理逻辑
        else:
            # 对于未知类型，你可以选择保留原样、跳过或引发异常
            # 这里我们选择保留原样
            return obj

    try:
        json_data = json.dumps(convert_datetime(all_index_k_line_property_dict), ensure_ascii=False, indent=4)
        # 将转换后的JSON字符串写入文件

        with open(constant.INDEX_K_BARS_PATH, 'w', encoding='utf-8') as f:
            f.write(json_data)
        # print(f"json_data:{json_data}")
    except Exception as error:
        print(f"An error occurred while converting the data to JSON: {error}")
    logger.info(f"加属性的指数k线写完了！{tool.get_now_time_str()}")


if __name__ == '__main__':
    # all_index_K_line_dict = get_index_K_line()

    all_index_k_line_dict_write()

 strategy/kpl_api.py

@@ -10,7 +10,8 @@
import requests

import constant
from log_module.log import logger_common, logger_kpl_jingxuan_in
from log_module import async_log_util
from log_module.log import logger_common, logger_kpl_jingxuan_in, logger_Overall_market_strength_score
# import requests
from strategy import data_cache
from strategy import basic_methods
@@ -230,29 +231,29 @@
                               '壳资源', '股权转让', '送转填权']) or ('增长' in plate_name):
            # print(f"{i[1]} 强度:{i[2]}")
            # 通过板块ID获取其下面的个股强度列表
            its_stock = getCodesByPlate(i[0])
            # print(f"======={i[0]}=======")
            its_stock = json.loads(its_stock)
            its_stock = json.loads(getCodesByPlate(i[0]))

            l = its_stock['list'][0]
            # print(f"its_stock['list']  ===  {its_stock['list']}")
            # print(f"its_stock['list'][0]  ===  {its_stock['list'][0]}")
            # logger.info(f"its_stock['list']  ===  {its_stock['list']}")
            logger.info(f"its_stock['list'][0]  ===  {its_stock['list'][0]}")
            logger.info(f"its_stock['list']  ===》》  {its_stock['list']}")
            # logger.info(f"its_stock['list'][0]  ===  {its_stock['list'][0]}")
            its_stock_list_info = its_stock['list'][0]

            # 将板块强度下面对应的个股列表打印到日志中
            # for i in l:
            #     if l[41] != 1:
            # for i in its_stock_list_info:
            #     if i[0] != 1:
            #         logger.info(
            #             f"l === 个股代码：{l[0]}，公司名称：{l[1]}，主力资金推测：{l[2]}，未知0值：{l[3]}，概念：{l[4]}，最新价：{l[5]}，当日当时涨幅：{l[6]}%，"
            #             f"成交额：{round(l[7] / 100000000, 2)} 亿，实际换手率：{l[8]}%，未知0值：{l[9]}，实际流通：{round(l[10] / 100000000, 2)}亿，"
            #             f"主力买：{round(l[11] / 100000000, 2)}亿，"
            #             f"主力卖：{round(l[12] / 100000000, 2)}亿，"
            #             f"主力净额：{round(l[13] / 10000, 2)}万，买成占比：{l[14]}%，卖成占比：{l[15]}%，净成占比：{l[16]}%，买流占比：{l[17]}%，卖流占比：{l[18]}%，净流占比：{l[19]}%，"
            #             f"区间涨幅：{l[20]}%，量比：{l[21]}，未知0：{l[22]}，上板情况：{l[23]}，上板排名：{l[24]}，换手率：{l[25]}%，"
            #             f"未知空值：{l[26]}，未知零值：{l[27]}，收盘封单：{l[28]}，最大封单：{l[29]}，未知空值？：{l[30]}，"
            #             f"？：{l[30]}%，？：{l[31]}，？？：{l[32]}，振幅：{l[33]}%，未知0？？？？：{l[34]}，未知0？？？？？：{l[35]}，"
            #             f"？=：{l[36]}，？总市值：{l[37]}，？流通市值：{l[38]}，最终归属概念（收盘后出数据？）：{l[39]}，领涨次数：{l[40]}，"
            #             f"41未知1值：{l[41]}，第三季度机构持仓【str数据勿用运算符】：{l[42]}万，？年预测净利润：{l[43]}，上年预测净利润：{l[44]}，年内预测净利润：{l[45]}"
            #             f"l === 个股代码：{i[0]}，公司名称：{i[1]}，主力资金推测：{i[2]}，未知0值：{i[3]}，概念：{i[4]}，最新价：{i[5]}，当日当时涨幅：{i[6]}%，"
            #             f"成交额：{round(i[7] / 100000000, 2)} 亿，实际换手率：{i[8]}%，未知0值：{i[9]}，实际流通：{round(i[10] / 100000000, 2)}亿，"
            #             f"主力买：{round(i[11] / 100000000, 2)}亿，"
            #             f"主力卖：{round(i[12] / 100000000, 2)}亿，"
            #             f"主力净额：{round(i[13] / 10000, 2)}万，买成占比：{i[14]}%，卖成占比：{i[15]}%，净成占比：{i[16]}%，买流占比：{i[17]}%，卖流占比：{i[18]}%，净流占比：{i[19]}%，"
            #             f"区间涨幅：{i[20]}%，量比：{i[21]}，未知0：{i[22]}，上板情况：{i[23]}，上板排名：{i[24]}，换手率：{i[25]}%，"
            #             f"未知空值：{i[26]}，未知零值：{i[27]}，收盘封单：{i[28]}，最大封单：{i[29]}，未知空值？：{i[30]}，"
            #             f"？：{i[30]}%，？：{i[31]}，？？：{i[32]}，振幅：{i[33]}%，未知0？？？？：{i[34]}，未知0？？？？？：{i[35]}，"
            #             f"？=：{i[36]}，？总市值：{i[37]}，？流通市值：{i[38]}，最终归属概念（收盘后出数据？）：{i[39]}，领涨次数：{i[40]}，"
            #             f"41未知1值：{i[41]}，第三季度机构持仓【str数据勿用运算符】：{i[42]}万，？年预测净利润：{i[43]}，上年预测净利润：{i[44]}，年内预测净利润：{i[45]}"
            #         )

            # 获取该概念板块的的子版块
@@ -744,11 +745,17 @@
                    data_cache.real_time_market_strong = get_market_strong()
                    # data_cache.time_sharing_market_strong_dirt = time_sharing_market_strong_dirt.update({now: data_cache.real_time_market_strong})
                    logger.info(f"大盘行情情绪综合强度 [分数]==={data_cache.real_time_market_strong}分")
                    # 大盘综合强度分数 的 异步日志
                    logger_Overall_market_strength_score.info(data_cache.real_time_market_strong)
                    async_log_util.info(logger_Overall_market_strength_score, f"大盘行情情绪综合强度 [分数]==={data_cache.real_time_market_strong}分")

                    usefulMoney = data_cache.account_finance_dict[0].get('usefulMoney', 0)
                    logger.info(f"账户可用资金==={usefulMoney}元")
                    # 低迷情绪比例
                    low_emotion_mood_ratio = 1
                    if data_cache.real_time_market_strong <= 33:
                    # 33分是个两级分化阶梯不好，目前不好拿捏，暂时不用
                    # if data_cache.real_time_market_strong <= 33:
                    if data_cache.real_time_market_strong <= 20:
                        low_emotion_mood_ratio = 0.1
                        if data_cache.real_time_market_strong <= 10:
                            low_emotion_mood_ratio = 0

 utils/juejin_api.py

@@ -42,6 +42,10 @@
    def current(cls, symbols, fields):
        return cls.__request("current", {"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})


class JueJinApi:
    # 获取交易所的代码
@@ -82,13 +86,20 @@
        # current_datas==[{'symbol': 'SZSE.001288', 'open': 30.27, 'high': 31.77, 'low': 30.27, 'price': 30.77, 'quotes': [{'bid_p': 30.77, 'bid_v': 500, 'ask_p': 30.78, 'ask_v': 3900}, {'bid_p': 30.76, 'bid_v': 800, 'ask_p': 30.79, 'ask_v': 3100}, {'bid_p': 30.75, 'bid_v': 21900, 'ask_p': 30.8, 'ask_v': 22100}, {'bid_p': 30.72, 'bid_v': 1300, 'ask_p': 30.82, 'ask_v': 300}, {'bid_p': 30.7, 'bid_v': 600, 'ask_p': 30.83, 'ask_v': 2700}], 'cum_volume': 2586914, 'cum_amount': 80020708.18, 'trade_type': 8, 'created_at': datetime.datetime(2025, 2, 12, 14, 50, 18, tzinfo=datetime.timezone(datetime.timedelta(seconds=28800)))}]
        return current

    @classmethod
    def history_n(cls, symbol, frequency, count, adjust, fields):
        return JueJinHttpApi.history_n(symbol, frequency, count, adjust, fields)


if __name__ == '__main__':

# if __name__ == '__main__':
#     datas = JueJinApi.history_n("SHSE.000300", "1d", 10, 1, "high")
#     print(datas)

    # 获取目标代码（获取目标票）
    # print(f"JueJinApi.get_exchanges_codes==={JueJinApi.get_exchanges_codes(['SHSE', 'SZSE'])}")
    symbols = ['SZSE.001288', 'SZSE.000042']
    fields = 'symbol,open'
    # symbols = ['SZSE.001288', 'SZSE.000042']
    # fields = 'symbol,open'
    # JueJinApi.get_codes_open(symbols, fields)
    #
    # strategy.data_cache.all_stocks = JueJinApi.get_exchanges_codes(["SHSE", "SZSE"])