akquant 0.2.35__tar.gz → 0.2.36__tar.gz

{akquant-0.2.35 → akquant-0.2.36}/Cargo.lock

@@ -30,7 +30,7 @@ dependencies = [
 
 [[package]]
 name = "akquant"
-version = "0.2.35"
+version = "0.2.36"
 dependencies = [
  "anyhow",
  "chrono",
@@ -41,12 +41,14 @@ dependencies = [
  "numpy",
  "polars",
  "pyo3",
+ "pyo3-log",
  "pyo3-stub-gen",
  "rayon",
  "rmp-serde",
  "rust_decimal",
  "rust_decimal_macros",
  "serde",
+ "serde_json",
  "thiserror",
  "uuid",
 ]
@@ -96,6 +98,15 @@ dependencies = [
  "object",
 ]
 
+[[package]]
+name = "arc-swap"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a3a1fd6f75306b68087b831f025c712524bcb19aad54e557b1129cfa0a2b207"
+dependencies = [
+ "rustversion",
+]
+
 [[package]]
 name = "argminmax"
 version = "0.6.3"
@@ -2255,6 +2266,17 @@ dependencies = [
  "pyo3-build-config",
 ]
 
+[[package]]
+name = "pyo3-log"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26c2ec80932c5c3b2d4fbc578c9b56b2d4502098587edb8bef5b6bfcad43682e"
+dependencies = [
+ "arc-swap",
+ "log",
+ "pyo3",
+]
+
 [[package]]
 name = "pyo3-macros"
 version = "0.28.2"

{akquant-0.2.35 → akquant-0.2.36}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "akquant"
-version = "0.2.35"
+version = "0.2.36"
 edition = "2024"
 description = "High-performance quantitative trading framework based on Rust and Python"
 license = "MIT"
@@ -30,8 +30,10 @@ csv = "1.3"
 thiserror = "2.0.18"
 rust_decimal_macros = "1.40"
 log = "0.4"
+pyo3-log = "0.13.1"
 crossbeam-channel = "0.5"
 rmp-serde = "1.3.1"
+serde_json = "1.0"
 
 [features]
 default = []

{akquant-0.2.35 → akquant-0.2.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: akquant
-Version: 0.2.35
+Version: 0.2.36
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{akquant-0.2.35 → akquant-0.2.36}/docs/en/guide/data.md

@@ -144,6 +144,38 @@ Parameter semantics:
 *   `align="day"`: Partition by day without `session_windows`; `day_mode` supports `trading/calendar`.
 *   `align="global"`: Aggregate on the full timeline without day partitioning.
 
+### 2.5 Using `DataFeed` Directly
+
+If you want explicit control over how data enters the engine, you can work with `DataFeed` directly instead of normalizing everything into a `DataFrame` first:
+
+```python
+import akquant as aq
+
+feed = aq.DataFeed.from_csv("/data/000001.csv", "000001.SZ")
+
+result = aq.run_backtest(
+    data=feed,
+    strategy=MyStrategy,
+    symbols="000001.SZ",
+    show_progress=False,
+)
+```
+
+For live scenarios, create a writable live feed:
+
+```python
+import akquant as aq
+
+feed = aq.DataFeed.create_live()
+feed.add_tick(aq.Tick(...))
+```
+
+Notes:
+
+*   `DataFeed.from_csv(...)` is a good fit when you want AKQuant to read a CSV-backed event stream directly.
+*   `add_bar(...)`, `add_bars(...)`, and `add_arrays(...)` fit cases where you already have normalized market objects or arrays on the Python side.
+*   If CSV or array inputs contain invalid floating-point values, Rust emits warnings that are forwarded into AKQuant's Python `logging` pipeline instead of failing silently.
+
 ---
 
 ## 3. Multi-Symbol Data

{akquant-0.2.35 → akquant-0.2.36}/docs/en/guide/optimization.md

@@ -201,6 +201,32 @@ When `max_workers > 1`, warning behavior is tied to `forward_worker_logs`:
 *   `forward_worker_logs=True` with active main-process logger handlers: log forwarding is enabled and visibility warning is suppressed.
 *   `forward_worker_logs=True` without active main-process handlers: warns that forwarding was requested but no handler is available.
 
+It is recommended to configure logging explicitly before launching optimization, especially when you want aggregated worker logs in the main process:
+
+```python
+import akquant
+
+akquant.configure_logging(
+    akquant.LogConfig(
+        profile="optimize",
+        level="INFO",
+        console=True,
+        filename="logs/optimize.log",
+        file_level="DEBUG",
+        file_json=True,
+        file_max_bytes=50_000_000,
+        file_backup_count=3,
+    )
+)
+```
+
+Notes:
+
+*   `profile="optimize"` includes process identity in the default format, which helps distinguish worker output.
+*   `forward_worker_logs=True` only forwards worker logs back to the main process; it does not create handlers automatically.
+*   If you only want quick console logging, `akquant.register_logger(level="INFO")` remains valid.
+*   If you want file logs to be easier for external log pipelines to consume, enable `file_json=True`.
+
 ### Persistence & Resume
 
 For scenarios with extremely large parameter sets (e.g., > 10,000 combinations), running on a single machine might take days. AKQuant supports real-time result persistence to SQLite, enabling breakpoint resume.

{akquant-0.2.35 → akquant-0.2.36}/docs/en/guide/strategy.md

@@ -212,6 +212,52 @@ def on_bar(self, bar):
     self.log("Insufficient funds", level=logging.WARNING)
 ```
 
+When log handlers are configured through `akquant.configure_logging(...)` or `akquant.register_logger(...)`, `self.log()` also carries structured context that is useful in `live` profile output and file logs:
+
+* `phase`: current stage such as `strategy`, `order`, or `trade`
+* `strategy_id` / `slot`: strategy identity in multi-strategy runs
+* `symbol`: current instrument
+* `event_time`: strategy event time
+* `order_id` / `client_order_id`: auto-filled inside `on_order` / `on_trade` / `on_reject`
+
+The simplest option remains the compatibility helper:
+
+```python
+import akquant
+
+akquant.register_logger(level="INFO")
+```
+
+For clearer research / optimize / live separation, prefer the structured config API:
+
+```python
+import akquant
+
+akquant.configure_logging(
+    akquant.LogConfig(
+        profile="live",
+        level="INFO",
+        console=True,
+        filename="logs/strategy.log",
+        file_level="DEBUG",
+        file_json=True,
+        file_max_bytes=10_000_000,
+        file_backup_count=5,
+    )
+)
+```
+
+If you want to ship logs into a log pipeline or collector, you can enable JSON output per handler:
+
+* `console_json=True`: console emits JSON lines
+* `file_json=True`: file emits JSON lines
+
+Practical guidance:
+
+* Use `self.log()` for human-readable strategy debugging
+* Use `run_backtest(..., on_event=...)` when you need a machine-consumable `order/trade/progress/risk` event stream
+* Inside `on_order`, `on_trade`, and `on_reject`, you usually do not need to manually concatenate order ids into the message
+
 ### 3.2 Data Access (Syntactic Sugar)
 
 The `Strategy` class provides properties for quick access to current Bar/Tick data:

{akquant-0.2.35 → akquant-0.2.36}/docs/en/reference/api.md

@@ -639,6 +639,101 @@ result = run_backtest(
 *   **UI-Driven Parameter Input**: Declare `PARAM_MODEL` in strategy classes (`akquant.ParamModel`) and use `get_strategy_param_schema` / `validate_strategy_params` for frontend-backend parameter consistency.
 *   **Parameter Tuning**: When using `run_grid_search`, modify the Config object or pass override parameters as needed.
 
+### Logging API
+
+AKQuant stays quiet by default when imported as a library; until explicitly configured, the `akquant` root logger only carries a `NullHandler`.
+
+#### `akquant.LogConfig`
+
+Advanced logging config object used by `configure_logging(...)`.
+
+Core fields:
+
+*   `level`: global fallback level.
+*   `console`: whether to enable the console handler.
+*   `console_level` / `file_level`: per-handler level overrides.
+*   `console_format` / `file_format`: text formatter overrides.
+*   `console_show_context` / `file_show_context`: whether human-readable output should append structured context.
+*   `console_json` / `file_json`: whether the corresponding handler should emit JSON lines.
+*   `filename`: target log file path.
+*   `file_mode`: file open mode, default `a`.
+*   `file_max_bytes` / `file_backup_count`: size-based rotation threshold and retention count.
+*   `profile`: preset profile, one of `research`, `optimize`, or `live`.
+*   `reset_handlers`: whether to reset AKQuant-managed handlers.
+*   `propagate`: whether records should propagate to parent loggers.
+
+#### `akquant.configure_logging`
+
+```python
+def configure_logging(config: LogConfig) -> logging.Logger
+```
+
+Initializes or reconfigures the `akquant` logging system through a structured config.
+
+Recommended example:
+
+```python
+import akquant
+
+akquant.configure_logging(
+    akquant.LogConfig(
+        profile="live",
+        level="INFO",
+        console=True,
+        console_json=False,
+        filename="logs/live.log",
+        file_level="DEBUG",
+        file_json=True,
+        file_max_bytes=10_000_000,
+        file_backup_count=5,
+    )
+)
+```
+
+Behavior notes:
+
+*   `profile` only fills unspecified fields; explicit config values always win.
+*   `profile="optimize"` uses a process-aware default text format so worker output is easier to distinguish.
+*   `profile="live"` is the natural place to enable structured context and/or JSON output.
+
+#### `akquant.register_logger`
+
+```python
+def register_logger(
+    filename: Optional[str] = None,
+    console: bool = True,
+    level: str = "INFO",
+) -> None
+```
+
+Compatibility helper for quickly enabling logging without exposing advanced fields. Internally this maps to `configure_logging(LogConfig(...))`.
+
+#### `akquant.get_logger`
+
+```python
+def get_logger(name: Optional[str] = None) -> logging.Logger
+```
+
+Fetches a logger under the `akquant` namespace:
+
+*   `get_logger()` -> `akquant`
+*   `get_logger("strategy")` -> `akquant.strategy`
+*   `get_logger("gateway.live")` -> `akquant.gateway.live`
+
+#### `akquant.set_log_level`
+
+```python
+def set_log_level(level: Union[str, int]) -> None
+```
+
+Updates the current `akquant` root logger level.
+
+#### Boundary Guidance
+
+*   `self.log(...)` is the primary human-readable strategy logging path.
+*   `run_backtest(..., on_event=...)` is the machine-consumable event stream and is better suited for realtime UI, alerting, and audit sinks.
+*   Inside `on_order` / `on_trade` / `on_reject`, `self.log(...)` automatically carries structured fields such as `order_id` and `client_order_id`.
+
 ### `akquant.RiskConfig`
 
 Configuration for risk management.
@@ -835,6 +930,30 @@ The main entry point for the backtesting engine (usually used implicitly via `ru
 *   `use_china_market()`: Enable China market.
 *   `set_stock_fee_rules(commission, stamp_tax, transfer_fee, min_commission)`: Set fee rules.
 
+### `akquant.DataFeed`
+
+`DataFeed` is the engine-facing event source abstraction. Use it when you want explicit control over how data enters the engine.
+
+**Constructors & factories:**
+
+*   `DataFeed()`: Create an empty historical feed.
+*   `DataFeed.from_csv(path, symbol)`: Create a feed directly from a CSV file; useful when you want Rust-side row iteration to drive the event stream.
+*   `DataFeed.create_live()`: Create a live feed suitable for gateway / market data push scenarios.
+
+**Input methods:**
+
+*   `add_bar(bar)`: Append one `Bar` to the feed.
+*   `add_bars(bars)`: Append a batch of `Bar` objects.
+*   `add_tick(tick)`: Append one `Tick` to a live feed.
+*   `add_arrays(timestamps, opens, highs, lows, closes, volumes, symbol)`: Build bars from arrays and inject them into the feed efficiently.
+*   `sort()`: Sort the current historical feed by event time.
+
+**When to use it:**
+
+*   For normal backtests, prefer `run_backtest(data=...)` with a `DataFrame`, `List[Bar]`, or `DataFeedAdapter`.
+*   Use `DataFeed` when you want to reuse the same feed object, switch explicitly between historical and live modes, or wire data into `Engine.add_data(feed)` yourself.
+*   If `from_csv(...)` or `add_arrays(...)` encounters invalid floating-point values, Rust emits warnings that flow into AKQuant's Python `logging` pipeline, such as `akquant.data.client` and `akquant.data.batch`.
+
 ### `akquant.gateway` Custom Broker Registry
 
 You can plug in a custom broker by name through the registry without editing built-in factory branches.

{akquant-0.2.35 → akquant-0.2.36}/docs/zh/guide/data.md

@@ -144,6 +144,38 @@ result = aq.run_backtest(
 *   `align="day"`：按日分区，不接收 `session_windows`；`day_mode` 支持 `trading/calendar`。
 *   `align="global"`：按全局时间轴聚合，不按交易日切段。
 
+### 2.5 直接使用 `DataFeed`
+
+如果你希望显式控制“数据如何进入引擎”，可以直接使用 `DataFeed`，而不必先转成 `DataFrame`：
+
+```python
+import akquant as aq
+
+feed = aq.DataFeed.from_csv("/data/000001.csv", "000001.SZ")
+
+result = aq.run_backtest(
+    data=feed,
+    strategy=MyStrategy,
+    symbols="000001.SZ",
+    show_progress=False,
+)
+```
+
+实时场景则可以创建可写入的 live feed：
+
+```python
+import akquant as aq
+
+feed = aq.DataFeed.create_live()
+feed.add_tick(aq.Tick(...))
+```
+
+补充说明：
+
+*   `DataFeed.from_csv(...)` 适合让 AKQuant 直接从 CSV 事件流读取数据。
+*   `add_bar(...)` / `add_bars(...)` / `add_arrays(...)` 适合你已经在 Python 侧拿到标准化行情对象或数组。
+*   如果 CSV 或数组里出现非法浮点值，Rust 侧会发出 warning，并通过 AKQuant 的 Python `logging` 输出，而不是静默吞掉。
+
 ---
 
 ## 3. 多标的数据 (Multi-Symbol Data)

{akquant-0.2.35 → akquant-0.2.36}/docs/zh/guide/optimization.md

@@ -201,6 +201,32 @@ if __name__ == "__main__":
 *   `forward_worker_logs=True` 且主进程存在有效 logger handler：启用日志回传，不再显示“不可见”提示。
 *   `forward_worker_logs=True` 但主进程无有效 logger handler：会提示“请求了日志回传但主进程无可用 handler”。
 
+推荐在运行优化前显式配置一次日志，尤其是你希望查看主进程聚合后的 worker 日志时：
+
+```python
+import akquant
+
+akquant.configure_logging(
+    akquant.LogConfig(
+        profile="optimize",
+        level="INFO",
+        console=True,
+        filename="logs/optimize.log",
+        file_level="DEBUG",
+        file_json=True,
+        file_max_bytes=50_000_000,
+        file_backup_count=3,
+    )
+)
+```
+
+说明：
+
+*   `profile="optimize"` 会在默认格式中带上进程名，便于区分不同 worker。
+*   `forward_worker_logs=True` 只负责“把子进程日志送回主进程”，不负责自动创建 handler。
+*   如果你只想快速打开控制台日志，也可以继续使用 `akquant.register_logger(level="INFO")`。
+*   如果你希望文件日志更方便被日志平台消费，可额外打开 `file_json=True`。
+
 ### 持久化与断点续传 (Persistence & Resume)
 
 对于参数组合极多（如 > 10,000 组）的场景，单机运行可能需要数小时甚至数天。如果中途断电或程序崩溃，重新运行将非常耗时。AKQuant 支持将优化结果实时写入 SQLite 数据库，并支持断点续传。

{akquant-0.2.35 → akquant-0.2.36}/docs/zh/guide/strategy.md

@@ -348,6 +348,52 @@ def on_bar(self, bar):
     self.log("资金不足", level=logging.WARNING)
 ```
 
+如果你已经通过 `akquant.configure_logging(...)` 或 `akquant.register_logger(...)` 配置了日志处理器，`self.log()` 还会自动附带结构化上下文，便于在 `live` profile 或文件日志中排障：
+
+* `phase`: 当前日志阶段，例如 `strategy`、`order`、`trade`
+* `strategy_id` / `slot`: 多策略场景下的策略身份
+* `symbol`: 当前标的
+* `event_time`: 策略事件时间
+* `order_id` / `client_order_id`: 在 `on_order` / `on_trade` / `on_reject` 内会自动补齐
+
+最简单的方式仍然是兼容接口：
+
+```python
+import akquant
+
+akquant.register_logger(level="INFO")
+```
+
+如果你想区分 research / optimize / live 场景，推荐使用结构化配置接口：
+
+```python
+import akquant
+
+akquant.configure_logging(
+    akquant.LogConfig(
+        profile="live",
+        level="INFO",
+        console=True,
+        filename="logs/strategy.log",
+        file_level="DEBUG",
+        file_json=True,
+        file_max_bytes=10_000_000,
+        file_backup_count=5,
+    )
+)
+```
+
+如果你要把日志送到日志平台或采集系统，也可以为控制台或文件单独开启 JSON 输出：
+
+* `console_json=True`: 控制台输出 JSON line
+* `file_json=True`: 文件输出 JSON line
+
+实践建议：
+
+* 人类阅读的调试信息优先用 `self.log()`
+* 需要统一消费 `order/trade/progress/risk` 事件流时，优先用 `run_backtest(..., on_event=...)`
+* 如果你在 `on_order`、`on_trade`、`on_reject` 里写 `self.log()`，通常不需要再手动拼接订单 id
+
 ### 3.2 便捷数据访问 (Data Access)
 
 为了减少代码冗余，`Strategy` 类提供了当前 Bar/Tick 数据的快捷访问属性：

{akquant-0.2.35 → akquant-0.2.36}/docs/zh/reference/api.md

@@ -694,6 +694,101 @@ result = run_backtest(
 *   **页面化参数输入**: 在策略类中声明 `PARAM_MODEL`（`akquant.ParamModel`），并使用 `get_strategy_param_schema` / `validate_strategy_params` 完成前后端参数联动与校验。
 *   **参数调优**: 使用 `run_grid_search` 时，通常通过修改 Config 对象或传入 override 参数来实现。
 
+### 日志配置 API (Logging)
+
+AKQuant 作为库使用时默认保持静默；未显式配置前，`akquant` 根 logger 仅挂载 `NullHandler`。
+
+#### `akquant.LogConfig`
+
+高级日志配置对象，供 `configure_logging(...)` 使用。
+
+核心字段：
+
+*   `level`: 全局回退等级。
+*   `console`: 是否启用控制台 handler。
+*   `console_level` / `file_level`: handler 级别覆盖。
+*   `console_format` / `file_format`: 文本 formatter 覆盖。
+*   `console_show_context` / `file_show_context`: 文本模式下是否附带结构化上下文。
+*   `console_json` / `file_json`: 是否对对应 handler 启用 JSON line 输出。
+*   `filename`: 文件日志路径。
+*   `file_mode`: 文件模式，默认 `a`。
+*   `file_max_bytes` / `file_backup_count`: 启用按大小轮转时的阈值与保留份数。
+*   `profile`: 预设 profile，支持 `research`、`optimize`、`live`。
+*   `reset_handlers`: 是否重置 AKQuant 自己管理的 handler。
+*   `propagate`: 是否向上游 logger 传播。
+
+#### `akquant.configure_logging`
+
+```python
+def configure_logging(config: LogConfig) -> logging.Logger
+```
+
+使用结构化配置初始化或重配 `akquant` 日志系统。
+
+推荐示例：
+
+```python
+import akquant
+
+akquant.configure_logging(
+    akquant.LogConfig(
+        profile="live",
+        level="INFO",
+        console=True,
+        console_json=False,
+        filename="logs/live.log",
+        file_level="DEBUG",
+        file_json=True,
+        file_max_bytes=10_000_000,
+        file_backup_count=5,
+    )
+)
+```
+
+行为说明：
+
+*   `profile` 只填充未显式指定的字段，显式参数优先级更高。
+*   `profile="optimize"` 默认文本格式会带 `processName`，便于区分 worker。
+*   `profile="live"` 适合打开结构化上下文或 JSON 输出。
+
+#### `akquant.register_logger`
+
+```python
+def register_logger(
+    filename: Optional[str] = None,
+    console: bool = True,
+    level: str = "INFO",
+) -> None
+```
+
+兼容快捷接口，适合快速打开日志，不暴露高级字段。内部会转成 `configure_logging(LogConfig(...))`。
+
+#### `akquant.get_logger`
+
+```python
+def get_logger(name: Optional[str] = None) -> logging.Logger
+```
+
+获取 `akquant` 命名空间下的 logger：
+
+*   `get_logger()` -> `akquant`
+*   `get_logger("strategy")` -> `akquant.strategy`
+*   `get_logger("gateway.live")` -> `akquant.gateway.live`
+
+#### `akquant.set_log_level`
+
+```python
+def set_log_level(level: Union[str, int]) -> None
+```
+
+修改当前 `akquant` 根 logger 的 level。
+
+#### 使用边界
+
+*   `self.log(...)` 面向人类阅读的策略调试日志。
+*   `run_backtest(..., on_event=...)` 面向机器消费的统一事件流，更适合实时 UI、告警、审计落盘。
+*   在 `on_order` / `on_trade` / `on_reject` 中使用 `self.log(...)` 时，日志会自动携带 `order_id` / `client_order_id` 等结构化字段。
+
 ## 2. 策略开发 (Strategy)
 
 ### `akquant.Strategy`
@@ -890,6 +985,30 @@ runner = LiveRunner(
 *   期货费率接口统一使用复数命名 `set_futures_fee_rules*`。
 *   旧单数命名 `set_future_fee_rules*` 已移除，不再对外暴露。
 
+### `akquant.DataFeed`
+
+`DataFeed` 是引擎内部的事件数据源封装，适合在你希望显式控制“数据如何进入引擎”时直接使用。
+
+**构造与工厂方法:**
+
+*   `DataFeed()`: 创建一个空的历史数据源。
+*   `DataFeed.from_csv(path, symbol)`: 直接从 CSV 文件创建数据源；适合由 Rust 侧按行读取并驱动事件流。
+*   `DataFeed.create_live()`: 创建实时数据源，适合供 gateway / 行情推送场景写入事件。
+
+**写入方法:**
+
+*   `add_bar(bar)`: 向数据源追加单个 `Bar`。
+*   `add_bars(bars)`: 向数据源批量追加 `Bar` 列表。
+*   `add_tick(tick)`: 向实时数据源追加单个 `Tick`。
+*   `add_arrays(timestamps, opens, highs, lows, closes, volumes, symbol)`: 通过数组快速批量构建 `Bar` 并注入数据源。
+*   `sort()`: 对当前历史数据源按事件时间排序。
+
+**使用边界:**
+
+*   若你只是做普通回测，优先使用 `run_backtest(data=...)`，直接传 `DataFrame`、`List[Bar]` 或 `DataFeedAdapter` 即可。
+*   若你需要复用同一数据源对象、显式切换历史/实时模式，或直接接入 `Engine.add_data(feed)`，则使用 `DataFeed` 更合适。
+*   `from_csv(...)` / `add_arrays(...)` 中如果遇到非法浮点值，Rust 侧会记录 warning，并通过 AKQuant 的 Python `logging` 体系输出，例如 `akquant.data.client`、`akquant.data.batch`。
+
 ### `akquant.gateway` 自定义 Broker 注册
 
 可通过注册表机制按名称接入自定义 broker，而无需修改内置工厂分支。

{akquant-0.2.35 → akquant-0.2.36}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "akquant"
-version = "0.2.35"
+version = "0.2.36"
 description = "High-performance quantitative trading framework based on Rust and Python"
 readme = "README.md"
 license = {text = "MIT License"}

{akquant-0.2.35 → akquant-0.2.36}/python/akquant/__init__.py

@@ -11,6 +11,7 @@ except metadata.PackageNotFoundError:
 __engine_rule_version__ = "1.0.0"  # Increment on behavior-changing updates
 
 from . import akquant as _akquant
+from . import log as _log
 from . import talib
 from .akquant import *  # noqa: F403
 from .akquant import ATR, EMA, MACD, RSI, SMA, BollingerBands
@@ -56,7 +57,6 @@ from .indicator_stream import (
     to_indicator_message,
     to_indicator_messages,
 )
-from .log import get_logger, register_logger
 from .optimize import OptimizationResult, run_grid_search, run_walk_forward
 from .params import (
     BoolParam,
@@ -85,6 +85,19 @@ from .utils import (
     prepare_dataframe,
 )
 
+if typing.TYPE_CHECKING:
+    from .log import LogConfig as LogConfig  # type: ignore[assignment]
+    from .log import configure_logging as configure_logging  # type: ignore[assignment]
+    from .log import get_logger as get_logger
+    from .log import register_logger as register_logger
+    from .log import set_log_level as set_log_level
+else:
+    globals()["LogConfig"] = _log.LogConfig
+    globals()["configure_logging"] = _log.configure_logging
+    globals()["get_logger"] = _log.get_logger
+    globals()["register_logger"] = _log.register_logger
+    globals()["set_log_level"] = _log.set_log_level
+
 __doc__ = _akquant.__doc__
 if hasattr(_akquant, "__all__"):  # noqa: F405
     __all__ = [name for name in _akquant.__all__ if name != "ExecutionMode"] + [  # noqa: F405
@@ -108,8 +121,11 @@ if hasattr(_akquant, "__all__"):  # noqa: F405
         "ParquetFeedAdapter",
         "ResampledFeedAdapter",
         "ReplayFeedAdapter",
+        "LogConfig",
+        "configure_logging",
         "get_logger",
         "register_logger",
+        "set_log_level",
         "strategy_config",
         "ChinaFuturesConfig",
         "ChinaFuturesFeeConfig",
@@ -187,8 +203,11 @@ else:
         "ParquetFeedAdapter",
         "ResampledFeedAdapter",
         "ReplayFeedAdapter",
+        "LogConfig",
+        "configure_logging",
         "get_logger",
         "register_logger",
+        "set_log_level",
         "strategy_config",
         "ChinaOptionsConfig",
         "ChinaOptionsFeeConfig",