logixbase 0.1.0__py3-none-any.whl

demos/build_demo.py

@@ -0,0 +1,11 @@
+import subprocess
+from pathlib import Path
+
+LOCAL_DIR = Path(__file__).parent
+
+
+if __name__ == "__main__":
+    # Execute in cmd
+    command = ["python", str(LOCAL_DIR.joinpath("build_demo_exec.py")), "build_ext", "--inplace"]
+    process = subprocess.Popen(command)
+    process.wait()

demos/build_demo_exec.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+import sys
+
+sys.path.append(str(Path(__file__).parent.parent))
+
+
+
+from logixbase.compiler import BuildProject
+
+
+if __name__ == "__main__":
+    self = BuildProject("Demoproject", r"D:\licx\codes\logixbase\demos\configs\compiler.ini", r"d:\logs")
+    self.start()
+    self.stop()

demos/concur_demo.py

@@ -0,0 +1,67 @@
+import time
+import random
+from pathlib import Path
+import sys
+
+sys.path.append(str(Path(__file__).parent.parent))
+
+from logixbase.executor import MultiTaskExecutor
+from logixbase.logger import LogManager
+
+# 示例函数（测试：参数组合、异常、内存返回）
+def example_task(x, y, delay=0.1, logger=None):
+    time.sleep(delay + random.uniform(0, 0.3))
+    if x == -1:
+        raise ValueError("intentional error")
+    output = x ** 2 + y
+    logger.INFO(f"Task input: x={x}, y={y} -> output={output}")
+    return {"input": (x, y), "output": output, "memory_usage": random.uniform(10, 50)}
+
+
+def generate_param_combinations():
+    param_set = []
+    for x in range(-1, 5):     # 包含一个错误任务（x = -1）
+        for y in [0, 1, 2]:     # 多参数组合测试
+            param_set.append((x, y))
+    return param_set
+
+
+def run_executor_demo(mode='process'):
+    print(f"\n==== Running {mode.upper()} mode demo ====")
+
+    loger = LogManager.get_instance(use_mp=True if mode in ("process", "pool") else False,
+                                    log_path=r'd:\logs')
+
+    executor = MultiTaskExecutor(mode=mode)
+    executor.bind_share(logger=loger)
+
+    # 多任务组合参数测试
+    for x, y in generate_param_combinations():
+        executor.submit(example_task, x, y, delay=0.1, group='combi', tags=[f"x={x}", f"y={y}"], task_name=f"task_{x}_{y}")
+
+    # 执行任务
+    executor.start()
+
+    if mode == 'pool':
+        executor.join()
+        loger.start()
+    else:
+        loger.start()
+        executor.join()
+    loger.stop()
+    # 报告与导出
+    executor.report(r"d:\logs", "csv", True)
+    # 错误与取消任务处理测试
+    failed = [tid for tid in executor.get_task_ids() if executor.get_status(tid) == 'error']
+    if failed:
+        print(f"Retrying failed tasks: {failed}")
+        executor.retry_failed()
+
+    any_id = executor.get_task_ids()[0]
+    executor.cancel_task(any_id)
+    executor.rerun_cancelled()
+
+if __name__ == "__main__":
+    run_executor_demo('thread')
+    # run_executor_demo('pool')
+    # run_executor_demo('process')

demos/configer_demo.py

@@ -0,0 +1,100 @@
+import multiprocessing
+import time
+from pathlib import Path
+import sys
+
+sys.path.append(str(Path(__file__).parent.parent.joinpath('logixbase')))
+
+from configer.loader import ConfigLoader
+from configer.schema import AppConfig  # 假设你已经在 schema.py 中定义好 AppConfig 结构
+
+CONFIG_PATH = Path(".\configs")  # 所有配置文件目录，需自行准备
+
+def test_1_load_single_path_all_formats():
+    print("\n--- Test 1: 加载多格式文件（无热更新） ---")
+    loader = ConfigLoader(CONFIG_PATH)
+    loader.load()
+    print("数据库地址:", loader.config.database.host)
+    print("邮件SMTP:", loader.config.mail.host)
+
+def test_2_ini_levels():
+    print("\n--- Test 2: 加载 INI 多层级（无热更新） ---")
+    loader = ConfigLoader(CONFIG_PATH, mode="prod")
+    loader.load()
+    print("Prod 模式密码:", loader.config.mail.password)
+
+def test_3_single_file_load():
+    print("\n--- Test 3: 加载单文件（无热更新） ---")
+    for suffix in [".ini", ".yaml", ".py"]:
+        file = CONFIG_PATH / f"CFG.base{suffix}"
+        print(f"\n加载文件: {file}")
+        loader = ConfigLoader(file)
+        loader.load()
+        print("邮箱用户名:", loader.config.mail.username)
+
+    loader = ConfigLoader(CONFIG_PATH / "cfg.ini")
+    loader.load()
+    print(f"\n加载文件: {CONFIG_PATH / 'cfg.ini'}")
+    print("邮箱用户名:", loader.config.mail.username)
+
+def test_4_single_proc_hot_reload():
+    print("\n--- Test 4: 单进程热更新测试（请手动修改配置文件观察） ---")
+    loader = ConfigLoader(CONFIG_PATH)
+    loader.load()
+    loader.start()
+
+    def on_change():
+        print(">>> 主进程回调: 新配置:", loader.config.mail.host)
+
+    loader.register_callback(on_change)
+
+    try:
+        while True:
+            time.sleep(2)
+    except KeyboardInterrupt:
+        loader.stop()
+        print("已停止热更新")
+
+def worker_proc(loader: ConfigLoader):
+    def on_child_update():
+        print(f"[子进程] 配置已更新：当前SMTP = {loader.config.mail.host}")
+    loader.register_mp_proxy()
+    loader.register_proxy_callback(on_child_update)
+    while True:
+        time.sleep(2)
+
+def test_5_multi_proc_hot_reload():
+    print("\n--- Test 5: 多进程热更新测试（请手动修改配置文件观察） ---")
+    loader = ConfigLoader(CONFIG_PATH, use_proxy=True)
+    loader.load()
+
+    # 启动子进程
+    processes = []
+    for _ in range(2):
+        p = multiprocessing.Process(target=worker_proc, args=(loader,))
+        p.start()
+        processes.append(p)
+
+    def on_main_update():
+        print("[主进程] 配置已更新：当前数据库地址 =", loader.config.database.host)
+
+    loader.register_callback(on_main_update)
+    loader.start(CONFIG_PATH)
+
+    try:
+        while True:
+            time.sleep(2)
+    except KeyboardInterrupt:
+        for p in processes:
+            p.terminate()
+        loader.stop()
+        print("已终止所有子进程与热更新")
+
+
+if __name__ == "__main__":
+    # 执行入口（如需测试，请取消注释一项）
+    # test_1_load_single_path_all_formats()
+    # test_2_ini_levels()
+    # test_3_single_file_load()
+    # test_4_single_proc_hot_reload()
+    test_5_multi_proc_hot_reload()

demos/coordinator_demo.py

@@ -0,0 +1,70 @@
+import time
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+
+from logixbase.logger import LogManager
+from logixbase.executor import Coordinator
+
+
+def once_task(x, y, sum_val, from_upstream, logger=None):
+    """Once 模式任务：执行一次并返回结果字典。"""
+    logger.INFO(f"[ONCE] x={x}, y={y}, sum_val={sum_val}, from_upstream={from_upstream}")
+    return {"x": x, "y": y, "sum_val": sum_val, "from_upstream": from_upstream}
+
+
+def hybrid_task(prefix, from_upstream, logger=None):
+    """Hybrid 模式任务：每轮处理上游数据并返回字符串。"""
+    logger.INFO(f"[HYBRID] prefix={prefix}, from_upstream={from_upstream}")
+    return f"{prefix}-{from_upstream}"
+
+
+def loop_task(name, req_queue=None, pub_queue=None, stop_event=None, logger=None):
+    """Loop 模式任务：持续监听 req_queue 并将处理结果推入 pub_queue。"""
+    logger.INFO(f"[LOOP] {name} listening...")
+    while not stop_event.is_set():
+        try:
+            upstream = req_queue.get()
+            if upstream is None:
+                continue
+
+            logger.INFO(f"[LOOP] {name} got {upstream}")
+            pub_queue.put(f"{name}-{upstream}")
+        except Exception as e:
+            logger.ERROR(f"[LOOP] {name} failed: {e}")
+
+
+def run_demo(mode):
+    task_modes = ["once", "hybrid", "loop"]
+
+    for task_mode in task_modes:
+        logger = LogManager(use_mp=True if mode in ("process", "pool") else False, log_path=r'd:\logs\coordinator')
+        print(f"\n===== Running Coordinator Demo: mode = {task_mode} {mode} =====")
+        # 初始化 Coordinator
+        coor = Coordinator(mode=mode, task_mode=task_mode, max_workers=4)
+        coor.bind_share(logger=logger)
+
+        # 注册任务
+        if task_mode == "once":
+            coor.submit(1, once_task, 1, 2, 3, 4, task_name="onceA")
+            coor.submit(2, once_task, 4, 5, 9, upstream_keys=["from_upstream"], task_name="onceB")
+        elif task_mode == "hybrid":
+            coor.submit(1, hybrid_task, "H1", 123, task_name="hybridA")
+            coor.submit(2, hybrid_task, "H2", upstream_keys=["from_upstream"], task_name="hybridB")
+        else:  # loop
+            coor.submit(1, loop_task, name="L1", task_name="loopA")
+            coor.submit(2, loop_task, name="L2", task_name="loopB")
+
+        # 启动协调器
+        coor.start()
+        time.sleep(3)
+        logger.start()
+        # 运行一段时间以观察日志输出
+        time.sleep(5)
+        # 停止协调器
+        coor.stop()
+        logger.stop()
+
+if __name__ == "__main__":
+    run_demo("process")

demos/ctpgateway_demo.py

@@ -0,0 +1,46 @@
+import sys
+from pathlib import Path
+from multiprocessing import Queue
+
+sys.path.append(str(Path(__file__).parent.parent))
+
+from logixbase.gateway import ctp
+from logixbase.logger import LogManager
+from logixbase.configer import load_schema
+
+
+class Test:
+
+    def __init__(self):
+        super().__init__()
+        self.q = Queue()
+
+    def on_tick(self, tick):
+        """"""
+        if self.q.empty():
+            self.q.put(tick)
+
+
+if __name__ == "__main__":
+    loger = LogManager.get_instance(use_mp="process", log_path=r'd:\logs')
+    conn_cfg = load_schema(r'D:\licx\codes\usercfg\odin\account.ini', ctp.CtpConfig)
+    callback = Test()
+
+    gateway = ctp.CtpGateway(conn_cfg, loger)
+    gateway.register_callback(callback.on_tick)
+    gateway.connect()
+    info = gateway.subscribe(["i2509", "MA510", "lu2509", "rb2510"])
+    # instruments = spi.qry_instrument()
+    # margin = spi.qry_margin_rate("rb2410")
+    # comm = spi.qry_commission_rate("rb2410")
+    # tick = spi.qry_depth_market_data("rb2410")
+    # td_code = spi.qry_trading_code("SHFE")
+
+    if not callback.q.empty():
+        tick = callback.q.get()
+
+    self = ctp.CtpTickClean()
+    for k, v in info.items():
+        self.register(k, v)
+    tick = self.clean_tick(tick)
+

demos/demoproj/clear.py

@@ -0,0 +1,2 @@
+def clear():
+    pass

demos/demoproj/except_file.py

@@ -0,0 +1 @@
+print(123123123)

demos/demoproj/main.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+
+
+from demoproj.test import run
+
+
+if __name__ == "__main__":
+    print(run(100, 200))

demos/demoproj/test.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+
+def run(a: int, b: int) -> int:
+    return a+b

demos/feeder_demo.py

@@ -0,0 +1,120 @@
+import sys
+import pandas as pd
+sys.path.append(r'D:\licx\codes\logixbase')
+
+from logixbase.feeder import TinysoftFeeder, TinysoftConfig, TQSDKConfig
+from logixbase.configer import load_schema, read_config
+from logixbase.utils import unify_time, DatabaseConfig
+from logixbase.feeder.sqlfeeder import SqlServerFeeder
+from logixbase.feeder.tqfeeder import TqsdkFeeder
+
+
+
+def tinysoft_demo():
+    conn_cfg = load_schema(r'D:\licx\codes\usercfg\odin\account.ini', TinysoftConfig)
+    self = TinysoftFeeder(conn_cfg)
+    self.connect()
+    self.all_tradeday("2025-04-01", "2025-04-10", fmt="int", freq="W", day=0)
+    # 查询基础信息
+    basic_info = self.asset_info("future", "basic")
+    basic_info = self.asset_info("etf", "basic")
+    basic_info = self.asset_info("stock", "basic")
+    basic_info = self.asset_info("index", "basic")
+    # 查询期权基础信息
+    basic_info = self.asset_info("option", "basic", "2025-04-28")
+    #查询期货交易信息
+    self.asset_info("future", "trade")
+
+    self.asset_ticker("future", True)
+    self.asset_ticker("etf", True)
+    self.asset_ticker("stock", True)
+    self.asset_ticker("index", True)
+    self.asset_ticker("option", True)
+    self.option_underlying()
+    self.option_ticker_spec("20250402", "M")
+
+    self.asset_quote("future", "2025-04-02", "2025-04-02", interval="60m", ticker=["CZCE.MA.2505"])
+    self.asset_quote("stock", "2025-04-02", "2025-04-02", interval="60m", ticker=["SZSE.000001"])
+    self.asset_quote("ETF", "2025-04-02", "2025-04-02", interval="60m", ticker=["SZSE.159003"])
+    self.asset_quote("index", "2025-04-02", "2025-04-02", interval="60m", ticker=["SSE.SH000001"])
+    self.asset_quote("option", start="2015-03-02", end="2015-03-12", interval="60m", ticker=["SSE.OP10000002"])
+
+
+def sql_demo():
+    conn_cfg = load_schema(r'D:\licx\codes\usercfg\odin\db_cfg.ini', DatabaseConfig)
+    self = SqlServerFeeder(conn_cfg)
+    self.connect()
+    # self.all_trade_day("2025-04-01", "2025-04-10", fmt="int", freq="W", day=0)
+    # self.trade_time(["RB", "IF", "sc"], call_auction=True)
+    # self.asset_ticker("stock", True)
+
+    # self.asset_info("future", "basic")
+    # self.asset_info("future", "basic", product=["IF"])
+    # self.asset_info("future", "basic", ticker=["CFFEX.IF.2505", "CZCE.MA.HOT", "SHFE.rb"])
+    self.asset_info("future", "TRADE", ticker=["CFFEX.IF.2505", "CZCE.MA.HOT", "SHFE.rb"], use_schema=True)
+    # info = self.asset_info("future", "basic", use_schema=True)
+    # info = self.asset_info("future", "basic", product=["CFFEX.IF"], use_schema=True)
+    info = self.asset_info("future", "basic", ticker=["CFFEX.IF.2505", "CZCE.MA.HOT", "SHFE.rb"], use_schema=True)
+    info = self.asset_info("stock", "basic", ticker=['SSE.SH600520', 'SZSE.002520', 'SSE.STK.603009'], use_schema=True)
+    info = self.asset_info("etf", "basic", ticker=['SSE.ETF.159001', 'SZSE.ETF.510050'], use_schema=True)
+    info = self.asset_info("index", "basic", ticker=["SSE.IDX.SH000001", "SZSE.IDX.SZ399001"], use_schema=True)
+
+    # self.asset_main_ticker("future", "2025-04-01", "2025-04-10")
+    # self.asset_main_ticker("future", "2025-04-01", "2025-04-10", ['CFFEX.IF.2505', 'CZCE.MA.HOT', 'SHFE.rb.00', 'DCE.i'])
+
+    # self.asset_quote("future", "20250401", "20250402", "daily")
+    # self.asset_quote("future", "20250401", "20250402", "day")
+    self.asset_quote("future", "20250401", "20250402", "daily", ticker=['CFFEX.IF.2505', 'CZCE.MA.HOT', 'CZCE.MA.01', 'SHFE.rb.00', 'DCE.i'])
+    # self.asset_quote("future", "20250401", "20250402", "30min")
+    # self.asset_quote("future", "20250401", "20250402", "30min")
+    self.asset_quote("future", "20250401", "20250430", "m30", ticker=['CFFEX.IF.2505', 'CZCE.MA.HOT', 'CZCE.MA.01', 'SHFE.rb.00', 'DCE.i'])
+    self.asset_quote("future", "20250401", "20250430", "m35", ticker=['CFFEX.IF.2505', 'CZCE.MA.HOT', 'CZCE.MA.01', 'SHFE.rb.00', 'DCE.i'])
+    # self.asset_quote("future", "20250401", "20250402", "30m", product=["SHFE.rb", "CZZE.MA", "DCE.i.00"])
+    # self.asset_quote("future", "20250401", "20250402", "30min", ticker=["SHFE.rb2505", "CZCE.MA509", "DCE.i2509"])
+
+    # self.asset_quote("stock", "20250401", "20250402", "day")
+    # self.asset_quote("stock", "20250401", "20250402", "daily", product=["SZSE.000001", "SSE.600520"])
+    self.asset_quote("stock", "20250401", "20250402", "daily", ticker=["SZSE.000001", "SSE.SH600520"])
+    self.asset_quote("stock", "20250401", "20250402", "60min", ticker=["SZSE.000001", "SSE.SH600520"])
+    # self.asset_quote("stock", "20250401", "20250402", "m60", product=["SZSE.000001", "SSE.SH600520"])
+
+    # self.asset_quote("index", "20250401", "20250402", "day")
+    # self.asset_quote("index", "20250401", "20250402", "daily", product=["SSE.SH000001"])
+    # self.asset_quote("index", "20250401", "20250402", "daily", ticker=["SSE.SH000001"])
+    # self.asset_quote("index", "20250401", "20250402", "30min", ticker=["SSE.SH000001"])
+    # self.asset_quote("index", "20250401", "20250402", "m30", product=["SSE.SH000001"])
+
+    # self.asset_quote("etf", "20250401", "20250402", "day")
+    # self.asset_quote("etf", "20250401", "20250402", "daily", product=["SZSE.159660", "SZSE.SZ159662"])
+    # self.asset_quote("etf", "20250401", "20250402", "daily", ticker=["SZSE.159660", "SZSE.SZ159662"])
+    # self.asset_quote("etf", "20250401", "20250402", "30min", ticker=["SZSE.159660", "SZSE.SZ159662"])
+    # self.asset_quote("etf", "20250401", "20250402", "m30", product=["SZSE。159660", "SZSE.SZ159662"])
+
+    # self.asset_coef_adj("future", ["RB", "I"], "20250401", "20250430")
+
+    quote = self.asset_quote("future", "20250401", "20250430", "m35", ["SHFE.rb", "CFFEX.IF", "INE.sc", "CZCE.MA","INE.lu.00"], use_schema=True)
+    quote = self.asset_quote("index", "20250401", "20250430", "m35", ["SSE.IDX.SH000001"], use_schema=True)
+    quote = self.asset_quote("stock", "20250401", "20250430", "m25", ["SZSE.000001", "SSE.SH600520"], use_schema=True)
+    quote = self.asset_quote("etf", "20250401", "20250430", "m25", ["SZSE.159660", "SZSE.SZ159662"], use_schema=True)
+    quote1 = self.asset_quote("stock", "20250401", "20250430", "m18", ["SZSE.000001", "SZSE.SH600520"], use_schema=True)
+
+    merged = self.merge_schema(quote, quote1, is_bar=True)
+    quote_df = self.parse_bar_schema(merged)
+
+
+def tqsdk_demo():
+    conn_cfg = load_schema(r'D:\licx\codes\usercfg\odin\account.ini', TQSDKConfig)
+    self = TqsdkFeeder(conn_cfg['tqsdk'])
+    self.connect()
+
+    instrument = self.asset_ticker("future")
+    info = self.asset_info("future", "basic", ticker=["CFFEX.IF.2505", "CZCE.MA.2510", "SHFE.rb.2510"])
+    quote = self.asset_quote("future", start, end, interval, ticker=["CFFEX.IF.2505", "CZCE.MA.2510"])
+
+
+if __name__ == '__main__':
+    # tinysoft_demo()
+    # sql_demo()
+    start = "20250401"
+    end = "20250430"
+    interval = "60min"

demos/logger_demo.py

@@ -0,0 +1,160 @@
+import time
+import threading
+import multiprocessing
+import sys
+from pathlib import Path
+
+
+sys.path.append(str(Path(__file__).parent.parent))
+# 导入 Logger 模块
+from logixbase.logger import LogManager, auto_log
+
+# ---------------------------
+# 示例：使用装饰器自动记录函数执行日志
+# ---------------------------
+@auto_log
+def sample_function(x, y):
+    """
+    示例函数，用于演示 @auto_log 装饰器的使用。
+    该装饰器会自动记录函数开始、结束及执行时长信息。
+    """
+    time.sleep(1)  # 模拟耗时操作
+    return x + y
+
+
+# ---------------------------
+# 示例：单线程日志记录
+# ---------------------------
+def demo_single_thread_logging():
+    """演示在单线程环境下记录日志"""
+    logger = LogManager.get_instance(use_mp=False, log_path=r'd:\logs')
+    logger.INFO("【Single Thread Demo】开始单线程日志记录。")
+    for i in range(3):
+        logger.DEBUG(f"单线程记录调试信息 {i}")
+        time.sleep(0.3)
+    logger.INFO("【Single Thread Demo】单线程日志记录结束。")
+
+
+# ---------------------------
+# 示例：多线程日志记录
+# ---------------------------
+def demo_multithread_logging():
+    """演示在多线程环境下记录日志"""
+    logger = LogManager.get_instance(use_mp=False, log_path=r'd:\logs')
+    logger.INFO("【Multithread Demo】开始多线程日志记录。")
+
+    def worker(thread_id):
+        for i in range(3):
+            logger.DEBUG(f"线程 {thread_id} 记录调试信息 {i}")
+            time.sleep(0.3)
+
+    threads = [threading.Thread(target=worker, args=(i,)) for i in range(3)]
+    for t in threads:
+        t.start()
+    for t in threads:
+        t.join()
+    logger.INFO("【Multithread Demo】多线程日志记录结束。")
+
+
+# ---------------------------
+# 示例：多进程日志记录（类场景）
+# ---------------------------
+def process_worker(logger, proc_id):
+    """模拟多进程日志记录"""
+    for i in range(3):
+        # 将日志消息放入共享队列，由主进程统一写入日志
+        logger.INFO(f"[子进程 {proc_id}] 记录日志消息 {i}")
+        time.sleep(0.3)
+
+
+class MultiprocessLogger:
+    def __init__(self, use_mp=True):
+        # 每次初始化时都动态创建 LogManager 实例，确保 use_mp 参数正确
+        self.logger = LogManager.get_instance(use_mp=use_mp, log_path=r'd:\logs')
+
+        # 确保只有在多进程模式下才尝试访问 mp_queue
+        if self.logger.use_mp:
+            self.shared_queue = self.logger.log_writer.log_queue  # 获取共享队列
+        else:
+            self.shared_queue = None
+
+        self.processes = []
+
+    def demo_multiprocess_logging(self):
+        """演示多进程环境下记录日志"""
+        if self.shared_queue is None:
+            print("未启用多进程模式，无法演示多进程日志记录。")
+            return
+
+        logger = self.logger
+        logger.INFO("【Multiprocess Demo】开始多进程日志记录（共享队列方式）。")
+
+        # 启动多个子进程
+        for pid in range(2):  # 启动 2 个子进程
+            # p = multiprocessing.Process(target=process_worker, args=(self.shared_queue, pid))
+            p = multiprocessing.Process(target=process_worker, args=(self.logger, pid))
+            self.processes.append(p)
+            p.start()
+        self.logger.start()
+        # 等待所有子进程执行完毕
+        for p in self.processes:
+            p.join()
+        logger.INFO("【Multiprocess Demo】多进程日志记录结束。")
+
+
+# ---------------------------
+# 演示 Logger 模块常用用法
+# ---------------------------
+def demo_logger_usage(use_mp=False):
+    """综合演示 Logger 的常用用法，包括直接日志调用、装饰器、以及多线程、多进程场景"""
+    if use_mp:
+        # 多进程模式
+        print("\n执行多进程版本的日志记录...")
+        mp_logger = MultiprocessLogger(use_mp=True)
+        mp_logger.demo_multiprocess_logging()
+    else:
+        # 单进程模式
+        print("\n执行单进程版本的日志记录...")
+        # 单线程模式
+        logger_single_thread = LogManager.get_instance(use_mp=False, log_path=r'd:\logs')
+        logger_single_thread.INFO("【Single Thread Demo】开始演示单线程日志记录。")
+        demo_single_thread_logging()
+
+        # 多线程模式
+        logger_multithread = LogManager.get_instance(use_mp=False, log_path=r'd:\logs')
+        logger_multithread.INFO("【Multithread Demo】开始演示多线程日志记录。")
+        demo_multithread_logging()
+
+        # 演示装饰器：调用被 @auto_log 装饰的 sample_function
+        result = sample_function(5, 7)
+        LogManager.get_instance().INFO(f"sample_function(5, 7) 返回结果：{result}")
+
+    # 等待一段时间确保所有异步日志都写入（可根据实际情况调整时间）
+    time.sleep(5)
+    LogManager.get_instance().stop()
+    print("Logger demo 执行完毕，日志已写入至日志目录。")
+    log_path = LogManager.get_instance().config.get("log_path", "./logs")
+    print(f"请查看日志文件（目录：{log_path}）以验证输出。")
+
+
+# ---------------------------
+# Dashboard 用法说明
+# ---------------------------
+def demo_dashboard_usage():
+    print("\n--------------------------------------")
+    print("Dashboard 演示：")
+    print("请打开终端，执行以下命令启动 Dashboard：")
+    print("  uvicorn dashboard.main:app --reload")
+    print("启动后，在浏览器中访问 http://127.0.0.1:8000 即可查看实时日志查询界面。")
+    print("--------------------------------------\n")
+
+
+# ---------------------------
+# 主入口
+# ---------------------------
+if __name__ == '__main__':
+    # 控制是否使用多进程
+    demo_logger_usage(use_mp=True)  # 使用多进程版本
+    # demo_logger_usage(use_mp=False)  # 使用单进程版本
+    # demo_dashboard_usage()
+    print("Demo 演示完成。")