sec-core 0.1.0__py3-none-any.whl

sec_core/__init__.py

@@ -0,0 +1,3 @@
+"""Shared securities protocol contracts."""
+
+__version__ = "0.1.0"

sec_core/market_data/__init__.py

@@ -0,0 +1,66 @@
+"""Market-data message protocol helpers."""
+
+from sec_core.market_data.codec import decode_msgpack, encode_msgpack
+from sec_core.market_data.constants import (
+    BACKFILL_SOURCE,
+    DEFAULT_KLINE_PERIOD,
+    DEFAULT_KLINE_SCHEMA_VERSION,
+    DEFAULT_TICK_SCHEMA_VERSION,
+    KLINE_1M_V1_DATASET,
+    REALTIME_SOURCE,
+    TICK_V2_DATASET,
+)
+from sec_core.market_data.message_ids import (
+    backfill_kline_1m_v1_msg_id,
+    backfill_tick_v2_msg_id,
+    kline_1m_v1_msg_id,
+    message_id_for_subject,
+    tick_v2_msg_id,
+)
+from sec_core.market_data.subjects import (
+    ParsedSubject,
+    format_backfill_kline_subject,
+    format_backfill_tick_subject,
+    format_kline_subject,
+    format_tick_subject,
+    normalize_subject_prefix,
+    parse_market_data_subject,
+    parse_stock_code,
+    subject_for_prefix,
+    wildcard_for_prefix,
+)
+from sec_core.market_data.validators import (
+    validate_kline_1m_v1_payload,
+    validate_payload,
+    validate_tick_v2_payload,
+)
+
+__all__ = [
+    "BACKFILL_SOURCE",
+    "DEFAULT_KLINE_PERIOD",
+    "DEFAULT_KLINE_SCHEMA_VERSION",
+    "DEFAULT_TICK_SCHEMA_VERSION",
+    "KLINE_1M_V1_DATASET",
+    "ParsedSubject",
+    "REALTIME_SOURCE",
+    "TICK_V2_DATASET",
+    "backfill_kline_1m_v1_msg_id",
+    "backfill_tick_v2_msg_id",
+    "decode_msgpack",
+    "encode_msgpack",
+    "format_backfill_kline_subject",
+    "format_backfill_tick_subject",
+    "format_kline_subject",
+    "format_tick_subject",
+    "kline_1m_v1_msg_id",
+    "message_id_for_subject",
+    "normalize_subject_prefix",
+    "parse_market_data_subject",
+    "parse_stock_code",
+    "subject_for_prefix",
+    "tick_v2_msg_id",
+    "validate_kline_1m_v1_payload",
+    "validate_payload",
+    "validate_tick_v2_payload",
+    "wildcard_for_prefix",
+]

sec_core/market_data/codec.py

@@ -0,0 +1,19 @@
+"""MessagePack codec helpers."""
+
+from collections.abc import Mapping
+from typing import Any
+
+import msgpack
+
+
+def encode_msgpack(payload: Mapping[str, Any]) -> bytes:
+    """Encode payload using the shared MessagePack options."""
+    return msgpack.packb(dict(payload), use_bin_type=True, default=str)
+
+
+def decode_msgpack(data: bytes) -> dict[str, Any]:
+    """Decode MessagePack payload using the shared options."""
+    decoded = msgpack.unpackb(data, raw=False)
+    if not isinstance(decoded, dict):
+        raise ValueError("MessagePack payload must decode to a dict")
+    return decoded

sec_core/market_data/constants.py

@@ -0,0 +1,11 @@
+"""Market-data protocol constants."""
+
+TICK_V2_DATASET = "tick_v2"
+KLINE_1M_V1_DATASET = "kl_1m_v1"
+
+DEFAULT_TICK_SCHEMA_VERSION = "v2"
+DEFAULT_KLINE_SCHEMA_VERSION = "v1"
+DEFAULT_KLINE_PERIOD = "1m"
+
+REALTIME_SOURCE = "realtime"
+BACKFILL_SOURCE = "backfill"

sec_core/market_data/message_ids.py

@@ -0,0 +1,38 @@
+"""NATS message-id helpers for JetStream de-duplication."""
+
+from sec_core.market_data.constants import BACKFILL_SOURCE, KLINE_1M_V1_DATASET, TICK_V2_DATASET
+from sec_core.market_data.subjects import parse_market_data_subject
+
+
+def tick_v2_msg_id(stock_code: str, time_ms: int) -> str:
+    """Return realtime tick v2 message id."""
+    return f"tick:v2:{stock_code}:{int(time_ms)}"
+
+
+def backfill_tick_v2_msg_id(stock_code: str, time_ms: int) -> str:
+    """Return backfill tick v2 message id."""
+    return f"backfill:tick:v2:{stock_code}:{int(time_ms)}"
+
+
+def kline_1m_v1_msg_id(stock_code: str, time_ms: int) -> str:
+    """Return realtime 1m K-line v1 message id."""
+    return f"1m:{stock_code}:{int(time_ms)}"
+
+
+def backfill_kline_1m_v1_msg_id(stock_code: str, time_ms: int) -> str:
+    """Return backfill 1m K-line v1 message id."""
+    return f"backfill:kl:1m:{stock_code}:{int(time_ms)}"
+
+
+def message_id_for_subject(subject: str, stock_code: str, time_ms: int) -> str:
+    """Return message id matching a market-data subject."""
+    parsed = parse_market_data_subject(subject)
+    if parsed.dataset == TICK_V2_DATASET:
+        if parsed.source == BACKFILL_SOURCE:
+            return backfill_tick_v2_msg_id(stock_code, time_ms)
+        return tick_v2_msg_id(stock_code, time_ms)
+    if parsed.dataset == KLINE_1M_V1_DATASET:
+        if parsed.source == BACKFILL_SOURCE:
+            return backfill_kline_1m_v1_msg_id(stock_code, time_ms)
+        return kline_1m_v1_msg_id(stock_code, time_ms)
+    raise ValueError(f"Unsupported dataset: {parsed.dataset}")

sec_core/market_data/schemas.py

@@ -0,0 +1,151 @@
+"""Market-data schema field definitions."""
+
+from enum import Enum
+
+from sec_core.market_data.constants import KLINE_1M_V1_DATASET, TICK_V2_DATASET
+
+
+class FieldType(str, Enum):
+    """Logical field type without storage-engine dependencies."""
+
+    STRING = "string"
+    BOOL = "bool"
+    PRICE = "price"
+    AMOUNT = "amount"
+    INT64 = "int64"
+    INT32 = "int32"
+    INT8 = "int8"
+    FLOAT = "float"
+
+
+TICK_V2_FIELD_TYPES: dict[str, FieldType] = {
+    "schema_version": FieldType.INT32,
+    "market": FieldType.STRING,
+    "stock_code": FieldType.STRING,
+    "time_ms": FieldType.INT64,
+    "last_price": FieldType.PRICE,
+    "open": FieldType.PRICE,
+    "high": FieldType.PRICE,
+    "low": FieldType.PRICE,
+    "last_close": FieldType.PRICE,
+    "amount": FieldType.AMOUNT,
+    "volume": FieldType.INT64,
+    "pvolume": FieldType.INT64,
+    "stock_status": FieldType.INT8,
+    "open_int": FieldType.INT32,
+    "transaction_num": FieldType.INT32,
+    "pe": FieldType.FLOAT,
+    "vol_ratio": FieldType.FLOAT,
+    "speed_1_min": FieldType.FLOAT,
+    "speed_5_min": FieldType.FLOAT,
+    "settlement_price": FieldType.PRICE,
+    "last_settlement_price": FieldType.PRICE,
+    "bid_price_1": FieldType.PRICE,
+    "bid_price_2": FieldType.PRICE,
+    "bid_price_3": FieldType.PRICE,
+    "bid_price_4": FieldType.PRICE,
+    "bid_price_5": FieldType.PRICE,
+    "ask_price_1": FieldType.PRICE,
+    "ask_price_2": FieldType.PRICE,
+    "ask_price_3": FieldType.PRICE,
+    "ask_price_4": FieldType.PRICE,
+    "ask_price_5": FieldType.PRICE,
+    "bid_vol_1": FieldType.INT32,
+    "bid_vol_2": FieldType.INT32,
+    "bid_vol_3": FieldType.INT32,
+    "bid_vol_4": FieldType.INT32,
+    "bid_vol_5": FieldType.INT32,
+    "ask_vol_1": FieldType.INT32,
+    "ask_vol_2": FieldType.INT32,
+    "ask_vol_3": FieldType.INT32,
+    "ask_vol_4": FieldType.INT32,
+    "ask_vol_5": FieldType.INT32,
+}
+
+KLINE_1M_V1_FIELD_TYPES: dict[str, FieldType] = {
+    "schema_version": FieldType.INT32,
+    "market": FieldType.STRING,
+    "stock_code": FieldType.STRING,
+    "period": FieldType.STRING,
+    "time_ms": FieldType.INT64,
+    "open": FieldType.PRICE,
+    "high": FieldType.PRICE,
+    "low": FieldType.PRICE,
+    "close": FieldType.PRICE,
+    "volume": FieldType.INT64,
+    "amount": FieldType.AMOUNT,
+    "settlement_price": FieldType.PRICE,
+    "open_interest": FieldType.INT64,
+    "pre_close": FieldType.PRICE,
+    "suspend_flag": FieldType.INT8,
+    "is_final": FieldType.BOOL,
+}
+
+TICK_V2_REQUIRED_FIELDS = (
+    "schema_version",
+    "market",
+    "stock_code",
+    "time_ms",
+    "last_price",
+    "volume",
+    "bid_price_1",
+    "bid_vol_1",
+    "ask_price_1",
+    "ask_vol_1",
+)
+
+KLINE_1M_V1_REQUIRED_FIELDS = (
+    "schema_version",
+    "market",
+    "stock_code",
+    "period",
+    "time_ms",
+    "open",
+    "high",
+    "low",
+    "close",
+    "volume",
+    "amount",
+    "settlement_price",
+    "open_interest",
+    "pre_close",
+    "suspend_flag",
+    "is_final",
+)
+
+_FIELD_TYPES_BY_DATASET = {
+    TICK_V2_DATASET: TICK_V2_FIELD_TYPES,
+    KLINE_1M_V1_DATASET: KLINE_1M_V1_FIELD_TYPES,
+}
+_REQUIRED_FIELDS_BY_DATASET = {
+    TICK_V2_DATASET: TICK_V2_REQUIRED_FIELDS,
+    KLINE_1M_V1_DATASET: KLINE_1M_V1_REQUIRED_FIELDS,
+}
+_SCHEMA_VERSION_BY_DATASET = {
+    TICK_V2_DATASET: 2,
+    KLINE_1M_V1_DATASET: 1,
+}
+
+
+def field_types_for_dataset(dataset: str) -> dict[str, FieldType]:
+    """Return field types for a supported dataset."""
+    try:
+        return _FIELD_TYPES_BY_DATASET[dataset]
+    except KeyError as exc:
+        raise ValueError(f"Unsupported dataset: {dataset}") from exc
+
+
+def required_fields_for_dataset(dataset: str) -> tuple[str, ...]:
+    """Return required payload fields for a supported dataset."""
+    try:
+        return _REQUIRED_FIELDS_BY_DATASET[dataset]
+    except KeyError as exc:
+        raise ValueError(f"Unsupported dataset: {dataset}") from exc
+
+
+def schema_version_for_dataset(dataset: str) -> int:
+    """Return numeric schema version for a supported dataset."""
+    try:
+        return _SCHEMA_VERSION_BY_DATASET[dataset]
+    except KeyError as exc:
+        raise ValueError(f"Unsupported dataset: {dataset}") from exc

sec_core/market_data/subjects.py

@@ -0,0 +1,223 @@
+"""NATS subject helpers for market-data messages."""
+
+from dataclasses import dataclass
+from typing import Literal
+
+from sec_core.market_data.constants import (
+    BACKFILL_SOURCE,
+    DEFAULT_KLINE_PERIOD,
+    DEFAULT_KLINE_SCHEMA_VERSION,
+    DEFAULT_TICK_SCHEMA_VERSION,
+    KLINE_1M_V1_DATASET,
+    REALTIME_SOURCE,
+    TICK_V2_DATASET,
+)
+
+MarketDataSource = Literal["realtime", "backfill"]
+
+
+@dataclass(frozen=True)
+class ParsedSubject:
+    """Parsed market-data subject."""
+
+    dataset: str
+    market: str
+    code: str
+    stock_code: str
+    source: MarketDataSource
+    schema_version: str
+    period: str | None
+
+
+def parse_stock_code(stock_code: str) -> tuple[str, str]:
+    """Parse stock code like ``000001.SZ`` into ``("sz", "000001")``."""
+    if "." not in stock_code:
+        raise ValueError(f"Invalid stock code format: {stock_code}")
+    code, exchange = stock_code.split(".", 1)
+    market = exchange.lower()
+    if market not in {"sz", "sh", "bj"}:
+        raise ValueError(f"Unknown exchange: {exchange}")
+    if not code:
+        raise ValueError(f"Invalid stock code format: {stock_code}")
+    return market, code
+
+
+def normalize_schema_version(version: str | int) -> str:
+    """Normalize schema version to the ``vN`` form."""
+    if isinstance(version, int):
+        version = f"v{version}"
+    value = str(version).lower()
+    normalized = value if value.startswith("v") else f"v{value}"
+    if normalized not in {"v1", "v2"}:
+        raise ValueError(f"Unsupported schema version: {version}")
+    return normalized
+
+
+def schema_version_number(version: str | int) -> int:
+    """Return numeric schema version."""
+    return int(normalize_schema_version(version).removeprefix("v"))
+
+
+def format_tick_subject(
+    stock_code: str,
+    version: str | int = DEFAULT_TICK_SCHEMA_VERSION,
+) -> str:
+    """Format realtime tick subject."""
+    market, code = parse_stock_code(stock_code)
+    return f"tick.{normalize_schema_version(version)}.{market}.{code}"
+
+
+def format_backfill_tick_subject(
+    stock_code: str,
+    version: str | int = DEFAULT_TICK_SCHEMA_VERSION,
+) -> str:
+    """Format historical backfill tick subject."""
+    market, code = parse_stock_code(stock_code)
+    return f"backfill.tick.{normalize_schema_version(version)}.{market}.{code}"
+
+
+def format_kline_subject(
+    stock_code: str,
+    period: str = DEFAULT_KLINE_PERIOD,
+    version: str | int = DEFAULT_KLINE_SCHEMA_VERSION,
+) -> str:
+    """Format realtime K-line subject."""
+    market, code = parse_stock_code(stock_code)
+    return f"kl.{normalize_schema_version(version)}.{period}.{market}.{code}"
+
+
+def format_backfill_kline_subject(
+    stock_code: str,
+    period: str = DEFAULT_KLINE_PERIOD,
+    version: str | int = DEFAULT_KLINE_SCHEMA_VERSION,
+) -> str:
+    """Format historical backfill K-line subject."""
+    market, code = parse_stock_code(stock_code)
+    return f"backfill.kl.{normalize_schema_version(version)}.{period}.{market}.{code}"
+
+
+def normalize_subject_prefix(prefix: str) -> str:
+    """Normalize a subject prefix by stripping whitespace and dots."""
+    normalized = prefix.strip().strip(".")
+    if not normalized:
+        raise ValueError("subject prefix must not be empty")
+    return normalized
+
+
+def wildcard_for_prefix(prefix: str) -> str:
+    """Return wildcard subject for a prefix."""
+    return f"{normalize_subject_prefix(prefix)}.>"
+
+
+def subject_for_prefix(prefix: str, market: str, code: str) -> str:
+    """Return concrete subject for a prefix, market, and code."""
+    return f"{normalize_subject_prefix(prefix)}.{market}.{code}"
+
+
+def parse_market_data_subject(
+    subject: str,
+    *,
+    tick_prefix: str = "tick.v2",
+    kline_prefix: str = "kl.v1.1m",
+) -> ParsedSubject:
+    """Parse realtime or backfill market-data subject."""
+    subject = subject.strip()
+    for parser in (_parse_tick_subject, _parse_kline_subject):
+        parsed = parser(subject)
+        if parsed is not None:
+            return parsed
+    for dataset, prefix in (
+        (TICK_V2_DATASET, normalize_subject_prefix(tick_prefix)),
+        (KLINE_1M_V1_DATASET, normalize_subject_prefix(kline_prefix)),
+    ):
+        parsed = _parse_by_prefix(subject, dataset, prefix)
+        if parsed is not None:
+            return parsed
+    raise ValueError(f"Invalid market data subject: {subject}")
+
+
+def _parse_tick_subject(subject: str) -> ParsedSubject | None:
+    parts = subject.split(".")
+    if len(parts) == 4 and parts[0] == "tick":
+        _, version, market, code = parts
+        if version == "v2":
+            return _parsed_tick(market, code, REALTIME_SOURCE, version)
+    if len(parts) == 5 and parts[:2] == ["backfill", "tick"]:
+        _, _, version, market, code = parts
+        if version == "v2":
+            return _parsed_tick(market, code, BACKFILL_SOURCE, version)
+    return None
+
+
+def _parse_kline_subject(subject: str) -> ParsedSubject | None:
+    parts = subject.split(".")
+    if len(parts) == 5 and parts[0] == "kl":
+        _, version, period, market, code = parts
+        if version == "v1" and period == "1m":
+            return _parsed_kline(market, code, REALTIME_SOURCE, version, period)
+    if len(parts) == 6 and parts[:2] == ["backfill", "kl"]:
+        _, _, version, period, market, code = parts
+        if version == "v1" and period == "1m":
+            return _parsed_kline(market, code, BACKFILL_SOURCE, version, period)
+    return None
+
+
+def _parse_by_prefix(
+    subject: str,
+    dataset: str,
+    prefix: str,
+) -> ParsedSubject | None:
+    needle = f"{prefix}."
+    if not subject.startswith(needle):
+        return None
+    suffix = subject[len(needle):]
+    parts = suffix.split(".")
+    if len(parts) != 2 or not parts[0] or not parts[1]:
+        raise ValueError(f"Invalid market data subject: {subject}")
+    market, code = parts
+    source = BACKFILL_SOURCE if prefix.startswith("backfill.") else REALTIME_SOURCE
+    if dataset == TICK_V2_DATASET:
+        return _parsed_tick(market, code, source, "v2")
+    return _parsed_kline(market, code, source, "v1", "1m")
+
+
+def _parsed_tick(
+    market: str,
+    code: str,
+    source: MarketDataSource,
+    version: str,
+) -> ParsedSubject:
+    _validate_market_code(market, code)
+    return ParsedSubject(
+        dataset=TICK_V2_DATASET,
+        market=market.lower(),
+        code=code,
+        stock_code=f"{code}.{market.lower()}",
+        source=source,
+        schema_version=version,
+        period=None,
+    )
+
+
+def _parsed_kline(
+    market: str,
+    code: str,
+    source: MarketDataSource,
+    version: str,
+    period: str,
+) -> ParsedSubject:
+    _validate_market_code(market, code)
+    return ParsedSubject(
+        dataset=KLINE_1M_V1_DATASET,
+        market=market.lower(),
+        code=code,
+        stock_code=f"{code}.{market.upper()}",
+        source=source,
+        schema_version=version,
+        period=period,
+    )
+
+
+def _validate_market_code(market: str, code: str) -> None:
+    if market.lower() not in {"sz", "sh", "bj"} or not code:
+        raise ValueError(f"Invalid market data subject token: {market}.{code}")

sec_core/market_data/validators.py

@@ -0,0 +1,43 @@
+"""Payload validators for market-data schemas."""
+
+from collections.abc import Mapping
+from typing import Any
+
+from sec_core.market_data.constants import DEFAULT_KLINE_PERIOD, KLINE_1M_V1_DATASET, TICK_V2_DATASET
+from sec_core.market_data.schemas import (
+    KLINE_1M_V1_REQUIRED_FIELDS,
+    TICK_V2_REQUIRED_FIELDS,
+)
+
+
+def validate_tick_v2_payload(payload: Mapping[str, Any]) -> None:
+    """Validate a tick v2 payload contract."""
+    _require_fields(payload, TICK_V2_REQUIRED_FIELDS)
+    if int(payload["schema_version"]) != 2:
+        raise ValueError("tick v2 schema_version must be 2")
+
+
+def validate_kline_1m_v1_payload(payload: Mapping[str, Any]) -> None:
+    """Validate a 1m K-line v1 payload contract."""
+    _require_fields(payload, KLINE_1M_V1_REQUIRED_FIELDS)
+    if int(payload["schema_version"]) != 1:
+        raise ValueError("kl 1m v1 schema_version must be 1")
+    if payload["period"] != DEFAULT_KLINE_PERIOD:
+        raise ValueError("kl 1m v1 period must be 1m")
+
+
+def validate_payload(dataset: str, payload: Mapping[str, Any]) -> None:
+    """Validate payload for a supported dataset."""
+    if dataset == TICK_V2_DATASET:
+        validate_tick_v2_payload(payload)
+        return
+    if dataset == KLINE_1M_V1_DATASET:
+        validate_kline_1m_v1_payload(payload)
+        return
+    raise ValueError(f"Unsupported dataset: {dataset}")
+
+
+def _require_fields(payload: Mapping[str, Any], fields: tuple[str, ...]) -> None:
+    missing = [field for field in fields if field not in payload]
+    if missing:
+        raise ValueError(f"Missing required fields: {', '.join(missing)}")

sec_core-0.1.0.dist-info/METADATA

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: sec-core
+Version: 0.1.0
+Summary: Shared securities market-data protocol contracts
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: msgpack>=1.1.2
+Description-Content-Type: text/markdown
+
+# sec-core
+
+`sec-core` 是证券行情消息协议核心包，提供 subject 构造/解析、schema 常量、payload 校验、`Nats-Msg-Id` 生成和 MessagePack 编解码。
+
+安装：
+
+```bash
+uv add sec-core
+pip install sec-core
+```
+
+示例：
+
+```python
+from sec_core.market_data.subjects import format_tick_subject
+
+print(format_tick_subject("000001.SZ"))
+```
+
+输出：
+
+```text
+tick.v2.sz.000001
+```
+
+第一版支持：
+
+- `tick.v2.{market}.{code}`
+- `backfill.tick.v2.{market}.{code}`
+- `kl.v1.1m.{market}.{code}`
+- `backfill.kl.v1.1m.{market}.{code}`
+
+本包不依赖 `xtquant`、`nats-py` 或 `pyarrow`。

sec_core-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+sec_core/__init__.py,sha256=ZmkVoRzqCIjvtYJHiqN1Lr5Rl_q7CdwcNUMepfPRHFE,67
+sec_core/market_data/__init__.py,sha256=sNCoW_j1sFxvZvcM0_uaeYMyFjtER2d7SX1HJl352N8,1758
+sec_core/market_data/codec.py,sha256=NtN-KLfCwxT7075Iyq226RATgGF3ms7NEnsLUE_N860,593
+sec_core/market_data/constants.py,sha256=NIL3LJFzsfiuZw9uK-xzZRHYA2oitHfeFFzwrbEU2dQ,259
+sec_core/market_data/message_ids.py,sha256=b3MqSEJRFUV8ESIl7kFdftHRmVL5SUYOxQPf7ATqldM,1566
+sec_core/market_data/schemas.py,sha256=el_Bk3vcCHMt6o9jngUVeVd9GIAiTuqLfVQQPkARRac,4142
+sec_core/market_data/subjects.py,sha256=ZhJ3T9-5HW34yyI2Tmqiuy51-hBoXPeGgPCVFq-dT6k,7058
+sec_core/market_data/validators.py,sha256=WSOVasSW0H6EpZ1XUVXxLjHNZ4sFZLF9BxjIDJFs5KE,1602
+sec_core-0.1.0.dist-info/METADATA,sha256=hCjwfrooXMRzQF0v7PZsv6PmNGTbuZMHJrzNYgyhQvs,843
+sec_core-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+sec_core-0.1.0.dist-info/licenses/LICENSE,sha256=dcEDwJI-xKgeyZMSoFiV-ceuHq-YNPOhqP91paUwWXQ,1086
+sec_core-0.1.0.dist-info/RECORD,,

sec_core-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

sec_core-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 chonglie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.