qlib-sync 0.1.0__py3-none-any.whl

qlib_sync/mcp_server.py

@@ -0,0 +1,249 @@
+"""MCP server: let AI assistants check, update, and read the local A-share dataset.
+
+Run with `qlib-sync mcp` (stdio), or without installing: `uvx qlib-sync mcp`.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import datetime as dt
+import os
+import re
+import threading
+from pathlib import Path
+from typing import Any, Literal
+
+import anyio
+from mcp.server.mcpserver import MCPServer
+from mcp.server.mcpserver.exceptions import ToolError
+from mcp.types import ToolAnnotations
+
+from .cn import market
+from .cn.update import DEFAULT_SOURCE_URL, UpdateError, UpdateOptions, run_update
+
+DATA_DIR_ENV = "QLIB_SYNC_DATA_DIR"
+PRICE_FIELDS = ("open", "high", "low", "close", "vwap")
+ALL_FIELDS = (*PRICE_FIELDS, "volume", "amount", "change", "factor")
+DEFAULT_FIELDS = ("open", "high", "low", "close", "volume", "change")
+MAX_SYMBOLS = 20
+MAX_ROWS_LIMIT = 5000
+
+INSTRUCTIONS = """\
+Local China A-share daily data (Qlib format), installed and kept current by qlib-sync.
+Call cn_status first to see how recent the data is. If the user needs recent prices and
+an update is available, call cn_update (it takes about a minute and is safe: on any
+failure the previous data is restored). Symbols accept 600519, SH600519 or 600519.SH.
+cn_get_prices returns real traded prices by default; pass price_basis="adjusted" for the
+split- and dividend-adjusted series used in backtests. Data covers trading days only;
+the latest date is the last close, never intraday.
+"""
+
+_SYMBOL = re.compile(r"^(?:(SH|SZ|BJ)(\d{6})|(\d{6})(?:\.(SH|SZ|BJ))?)$")
+
+
+def normalize_symbol(value: str) -> str:
+    """Map 600519, sh600519, or 600519.SH to Qlib's SH600519."""
+    match = _SYMBOL.match(value.strip().upper())
+    if not match:
+        raise ToolError(f"unrecognized symbol {value!r}; use a 6-digit code such as 600519 or SH600519")
+    prefix, code = (match.group(1), match.group(2)) if match.group(1) else (match.group(4), match.group(3))
+    if prefix:
+        return f"{prefix}{code}"
+    if code.startswith("92") or code[0] in "48":
+        return f"BJ{code}"
+    if code[0] in "69":
+        return f"SH{code}"
+    return f"SZ{code}"
+
+
+class QlibReader:
+    """Initialize Qlib once per process and re-initialize after the data is replaced."""
+
+    def __init__(self, data_dir: Path):
+        self.data_dir = data_dir
+        self._ready = False
+        self._lock = threading.Lock()
+
+    def invalidate(self) -> None:
+        with self._lock:
+            self._ready = False
+
+    def _ensure(self) -> None:
+        # pylint: disable=import-outside-toplevel
+        import qlib
+        from qlib.config import REG_CN
+
+        if not (self.data_dir / "calendars" / "day.txt").is_file():
+            raise ToolError(f"no A-share data at {self.data_dir}; call cn_update to install it")
+        if not self._ready:
+            # kernels=1 keeps reads in-process; spawning workers per request is far slower.
+            qlib.init(provider_uri=str(self.data_dir), region=REG_CN, logging_level="ERROR", kernels=1)
+            self._ready = True
+
+    def prices(self, symbols: list[str], start: str, end: str, fields: list[str], adjusted: bool):
+        from qlib.data import D  # pylint: disable=import-outside-toplevel
+
+        with self._lock:
+            self._ensure()
+            columns = sorted(set(fields) | ({"factor"} if not adjusted else set()))
+            frame = D.features(symbols, [f"${name}" for name in columns], start_time=start, end_time=end)
+        frame.columns = [column.lstrip("$") for column in frame.columns]
+        if not adjusted:
+            # Qlib stores adjusted prices: raw = adjusted / factor, raw volume = adjusted * factor.
+            for name in PRICE_FIELDS:
+                if name in frame:
+                    frame[name] = frame[name] / frame["factor"]
+            if "volume" in frame:
+                frame["volume"] = frame["volume"] * frame["factor"]
+        frame = frame[[name for name in fields if name in frame]].dropna(how="all").astype("float64")
+        # Qlib stores float32; round away the noise so 1452.9998779 reads as 1453.0.
+        return frame.round({**{name: 3 for name in PRICE_FIELDS}, "volume": 0, "amount": 2, "change": 6, "factor": 6})
+
+    def pool(self, name: str, date: str | None) -> list[str]:
+        from qlib.data import D  # pylint: disable=import-outside-toplevel
+
+        with self._lock:
+            self._ensure()
+            day = date or market.read_latest_date(self.data_dir)
+            return sorted(D.list_instruments(D.instruments(name), start_time=day, end_time=day, as_list=True))
+
+
+def create_server(data_dir: Path | None = None, source_url: str = DEFAULT_SOURCE_URL) -> MCPServer:
+    # An empty variable (an unset option in an MCP client's config) means the default.
+    data_dir = (data_dir or Path(os.environ.get(DATA_DIR_ENV) or market.DEFAULT_DATA_DIR)).expanduser().resolve()
+    reader = QlibReader(data_dir)
+    server = MCPServer("qlib-sync", instructions=INSTRUCTIONS)
+
+    @server.tool(
+        name="cn_status",
+        annotations=ToolAnnotations(title="A-share data status", read_only_hint=True, open_world_hint=True),
+    )
+    def cn_status(offline: bool = False) -> dict[str, Any]:
+        """Report the local A-share data's latest trading date, size, and stock pools, and whether
+        the community release has newer data (set offline=True to skip the network check)."""
+        result = market.collect_status(data_dir, market.DEFAULT_PROTECTED_DIR, offline, 15)
+        result.pop("related_datasets", None)
+        result["pools"] = [pool["name"] for pool in result.pop("instrument_pools")]
+        result["today"] = dt.date.today().isoformat()
+        return result
+
+    @server.tool(
+        name="cn_update",
+        annotations=ToolAnnotations(
+            title="Update A-share data",
+            read_only_hint=False,
+            destructive_hint=False,
+            idempotent_hint=True,
+            open_world_hint=True,
+        ),
+    )
+    async def cn_update(force: bool = False) -> dict[str, Any]:
+        """Install or update the local A-share data from the community release.
+
+        Returns quickly when already current. Otherwise downloads about 550 MB, verifies its
+        checksum, and swaps it in; this takes roughly a minute. On any failure the previous
+        data is restored. The result lists new trading days and listed/delisted symbols.
+        """
+        options = UpdateOptions(
+            data_dir=data_dir, protected_dir=market.DEFAULT_PROTECTED_DIR, source_url=source_url, force=force
+        )
+        try:
+            result = await anyio.to_thread.run_sync(run_update, options)
+        except UpdateError as exc:
+            raise ToolError(f"update failed and the existing data is unchanged: {exc}") from exc
+        if result.status != "up_to_date":
+            reader.invalidate()
+        payload = dataclasses.asdict(result)
+        payload["summary"] = result.summary_lines()
+        return payload
+
+    @server.tool(
+        name="cn_health_check",
+        annotations=ToolAnnotations(title="Check A-share data", read_only_hint=True, open_world_hint=False),
+    )
+    async def cn_health_check() -> dict[str, Any]:
+        """Validate the local data's structure and perform a real Qlib read; returns ok, errors, checks."""
+        return await anyio.to_thread.run_sync(market.health_check, data_dir, market.DEFAULT_PROTECTED_DIR)
+
+    @server.tool(
+        name="cn_get_prices",
+        annotations=ToolAnnotations(title="Get A-share daily prices", read_only_hint=True, open_world_hint=False),
+    )
+    async def cn_get_prices(
+        symbols: list[str],
+        start: str,
+        end: str | None = None,
+        fields: list[str] | None = None,
+        price_basis: Literal["raw", "adjusted"] = "raw",
+        max_rows: int = 500,
+    ) -> dict[str, Any]:
+        """Daily bars for up to 20 A-share symbols between start and end (YYYY-MM-DD, inclusive;
+        end defaults to the latest date).
+
+        fields: any of open, high, low, close, vwap, volume, amount, change, factor
+        (default open, high, low, close, volume, change). change is the daily return as a
+        fraction (0.01 = +1%). price_basis="raw" gives real traded prices and share volume;
+        "adjusted" gives Qlib's split- and dividend-adjusted series. Rows are capped by max_rows.
+        """
+        if not symbols:
+            raise ToolError("pass at least one symbol, for example ['600519']")
+        if len(symbols) > MAX_SYMBOLS:
+            raise ToolError(f"at most {MAX_SYMBOLS} symbols per call; split the request")
+        wanted = list(fields or DEFAULT_FIELDS)
+        unknown = sorted(set(wanted) - set(ALL_FIELDS))
+        if unknown:
+            raise ToolError(f"unknown fields {unknown}; choose from {list(ALL_FIELDS)}")
+        codes = [normalize_symbol(symbol) for symbol in symbols]
+        for value in (start, end):
+            if value is not None and not re.fullmatch(r"\d{4}-\d{2}-\d{2}", value):
+                raise ToolError(f"dates must be YYYY-MM-DD, got {value!r}")
+        limit = max(1, min(max_rows, MAX_ROWS_LIMIT))
+        latest = market.read_latest_date(data_dir)
+        frame = await anyio.to_thread.run_sync(
+            reader.prices, codes, start, end or latest, wanted, price_basis == "adjusted"
+        )
+        rows = [
+            {"symbol": symbol, "date": day.date().isoformat(), **{k: _clean(v) for k, v in values.items()}}
+            for (symbol, day), values in frame.to_dict(orient="index").items()
+        ]
+        missing = sorted(set(codes) - {row["symbol"] for row in rows})
+        return {
+            "price_basis": price_basis,
+            "data_latest_date": latest,
+            "rows": rows[:limit],
+            "total_rows": len(rows),
+            "truncated": len(rows) > limit,
+            "symbols_without_data": missing,
+        }
+
+    @server.tool(
+        name="cn_list_pool",
+        annotations=ToolAnnotations(title="List stock pool members", read_only_hint=True, open_world_hint=False),
+    )
+    async def cn_list_pool(pool: str = "csi300", date: str | None = None) -> dict[str, Any]:
+        """Members of a stock pool on a date (default: the latest date). Pools: all, csi100, csi300,
+        csi500, csi800, csi1000, csiall, plus any local pools; cn_status lists what exists."""
+        available = sorted(path.stem for path in (data_dir / "instruments").glob("*.txt"))
+        if pool not in available:
+            raise ToolError(f"unknown pool {pool!r}; available: {available}")
+        members = await anyio.to_thread.run_sync(reader.pool, pool, date)
+        return {"pool": pool, "date": date or market.read_latest_date(data_dir), "count": len(members), "symbols": members}
+
+    return server
+
+
+def _clean(value: float) -> float | None:
+    return None if value != value else value  # NaN -> null in JSON
+
+
+def main(argv: list[str] | None = None) -> None:
+    import argparse  # pylint: disable=import-outside-toplevel
+
+    parser = argparse.ArgumentParser(prog="qlib-sync mcp", description="Serve the A-share dataset over MCP (stdio).")
+    parser.add_argument("--data-dir", type=Path, help=f"Dataset directory (default: ${DATA_DIR_ENV} or ~/.qlib/qlib_data/cn_data)")
+    args = parser.parse_args(argv)
+    create_server(args.data_dir).run("stdio")
+
+
+if __name__ == "__main__":
+    main()

qlib_sync/txn.py

@@ -0,0 +1,71 @@
+"""Transactional replacement of a dataset directory.
+
+A dataset is replaced with two renames: the active directory moves aside to a
+backup path, then the staged directory moves into place. A verification step
+then runs against the new data. If anything fails after the first rename, the
+previous directory is put back, so the active path ends up holding either the
+complete old dataset or the complete, verified new one.
+
+Renames are atomic only within one filesystem, so callers stage new data next
+to the active directory rather than in a system temp directory.
+"""
+
+from __future__ import annotations
+
+import shutil
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Callable, Iterator
+
+
+class LockedError(RuntimeError):
+    """Another operation already holds the lock."""
+
+
+@contextmanager
+def exclusive_lock(lock_dir: Path) -> Iterator[None]:
+    """Hold a lock for the duration of the block.
+
+    `mkdir` either creates the directory or fails, atomically, on every platform,
+    which makes a directory a dependable cross-process lock without extra packages.
+    """
+    try:
+        lock_dir.mkdir()
+    except FileExistsError as exc:
+        raise LockedError(f"another operation is already running (lock: {lock_dir})") from exc
+    try:
+        yield
+    finally:
+        lock_dir.rmdir()
+
+
+def replace_directory(
+    active: Path,
+    staged: Path,
+    backup: Path,
+    verify: Callable[[Path], None] | None = None,
+) -> Path | None:
+    """Swap `staged` into the `active` path and verify it.
+
+    Returns the backup path holding the previous directory, or None when there was
+    no previous directory. The caller decides whether to keep or delete the backup.
+    On any failure the previous state is restored and the exception propagates.
+    """
+    if backup.exists():
+        raise FileExistsError(f"backup path already exists: {backup}")
+    had_previous = active.exists()
+    if had_previous:
+        active.rename(backup)
+    try:
+        staged.rename(active)
+        if verify is not None:
+            verify(active)
+    except BaseException:
+        # Whatever now sits at the active path is the new data that failed; the
+        # staged copy is disposable, so remove it before moving the old data back.
+        if active.exists():
+            shutil.rmtree(active)
+        if had_previous:
+            backup.rename(active)
+        raise
+    return backup if had_previous else None

qlib_sync-0.1.0.dist-info/METADATA

@@ -0,0 +1,219 @@
+Metadata-Version: 2.5
+Name: qlib-sync
+Version: 0.1.0
+Summary: Safely install and update a local Qlib China A-share dataset, with an MCP server for AI assistants.
+Project-URL: Homepage, https://github.com/randyy179/qlib-sync
+Project-URL: Issues, https://github.com/randyy179/qlib-sync/issues
+Project-URL: Changelog, https://github.com/randyy179/qlib-sync/releases
+Author: randyy179
+License: MIT
+License-File: LICENSE
+Keywords: a-share,china,market-data,mcp,qlib,quant,stock
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: <3.13,>=3.10
+Requires-Dist: mcp<3,>=2.3
+Requires-Dist: pyqlib>=0.9.6
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# qlib-sync
+
+[![CI](https://github.com/randyy179/qlib-sync/actions/workflows/ci.yml/badge.svg)](https://github.com/randyy179/qlib-sync/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/qlib-sync)](https://pypi.org/project/qlib-sync/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/randyy179/qlib-sync/blob/main/LICENSE)
+
+[中文说明](https://github.com/randyy179/qlib-sync/blob/main/README.zh-CN.md)
+
+**Website:** [randyy179.github.io/qlib-sync](https://randyy179.github.io/qlib-sync/)
+
+<!-- mcp-name: io.github.randyy179/qlib-sync -->
+
+**One command to install and keep current a local [Qlib](https://github.com/microsoft/qlib) China A-share dataset, and an MCP server so AI assistants can read it.**
+
+```bash
+pip install qlib-sync
+qlib-sync cn update
+```
+
+Or without installing anything first: `uvx qlib-sync cn update`.
+
+![qlib-sync updating the dataset: status, download with progress, checksum, summary, then an instant no-op](https://raw.githubusercontent.com/randyy179/qlib-sync/main/docs/assets/demo-update.gif)
+
+That installs the daily community release from
+[chenditc/investment_data](https://github.com/chenditc/investment_data) into
+`~/.qlib/qlib_data/cn_data`, the location Qlib reads by default. Run the same command again
+any time; when the data is already current it finishes in about a second.
+
+## Why not just `wget` and `tar`?
+
+<img src="https://raw.githubusercontent.com/randyy179/qlib-sync/main/docs/assets/comic.jpg" width="560" alt="Four-panel comic: a download dies at 99% at night; the next day 550 MB arrive and nothing changed; the qlib-sync robot checks the data and stamps it verified, keeping the old copy safe; the researcher sips tea and asks an AI for Moutai's recent closes">
+
+Qlib's README points A-share users to the community release with a `wget` and `tar` one-liner.
+That works until it doesn't:
+
+- **An interrupted or truncated download** extracts into a half-written dataset, or fails
+  after the old one has already been overwritten.
+- **Upstream republishes releases.** In November 2026 a data error was found and corrected
+  ([investment_data#163](https://github.com/chenditc/investment_data/issues/163)) and releases
+  were republished under the same date. A date check alone never sees the fix.
+- **Every check downloads 550 MB**, even when nothing changed.
+
+The investment_data README itself describes a careful manual process: download the release
+manifest, check the archive with its `validate_archive.py`, then extract. qlib-sync runs the
+same checks automatically on every update and adds what a manual process cannot: it skips the
+download when nothing changed, extracts beside the live data and swaps it in with rollback
+(rather than extracting on top of the existing folder), and picks up republished releases.
+
+qlib-sync treats the dataset like a production system:
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/randyy179/qlib-sync/main/docs/assets/update-flow-dark.svg">
+  <img alt="Update flow: check the manifest, download, verify, stage, swap; any failure puts the previous dataset back" src="https://raw.githubusercontent.com/randyy179/qlib-sync/main/docs/assets/update-flow-light.svg">
+</picture>
+
+| Step | What happens |
+|---|---|
+| Check | Reads the release's 500-byte manifest. Already current: done, nothing downloaded. |
+| Download | Resumes interrupted downloads; shows progress; optional mirror for slow links to GitHub. |
+| Verify | Size and sha256 from the manifest; the same release checks as upstream's `validate_archive.py` (every index pool and the future calendar reach the manifest's dates, release marked publishable); archive paths and links are checked before extraction. |
+| Stage | Extracts next to the active dataset; refuses downgrades. |
+| Swap | Renames the new dataset into place, then runs a real Qlib read. |
+| Roll back | Any failure after the swap moves the previous dataset back. |
+| Report | New trading days, newly listed and delisted symbols. |
+
+The checks catch broken, truncated, or tampered packages. They cannot catch wrong values inside a
+correctly published release (like the one in #163); for that, keep a rollback copy with
+`--keep-backup`.
+
+## Commands
+
+```bash
+qlib-sync status                  # every local Qlib dataset at a glance
+qlib-sync cn status               # local date, pools, and whether a newer release exists
+qlib-sync cn update               # install or update (add --json for machine-readable output)
+qlib-sync cn health-check         # structure checks plus a real Qlib read
+qlib-sync cn restore --list       # rollback backups; restore --yes switches back
+```
+
+Useful options for `cn update`:
+
+| Option | Effect |
+|---|---|
+| `--data-dir PATH` | Install somewhere other than `~/.qlib/qlib_data/cn_data` |
+| `--mirror URL` | Download through a prefix-style GitHub proxy such as `https://ghfast.top` (or set `QLIB_SYNC_MIRROR`) |
+| `--keep-backup` | Keep the previous dataset for one rollback |
+| `--protect FILE` | Carry a custom stock pool in `instruments/` across updates (repeatable) |
+| `--force` | Reinstall even when the dates match |
+
+**The update replaces the whole `cn_data` folder.** Anything you added there is lost unless you
+pass it with `--protect`.
+
+### Mirrors
+
+From mainland China, GitHub downloads can be slow or fail. Pass a mirror and qlib-sync downloads
+the package through it while still reading the manifest from GitHub directly when it can, so the
+checksum does not depend on the mirror. Mirrors are third-party services; qlib-sync does not
+endorse any of them.
+
+## Python
+
+```python
+from qlib_sync import update_cn, status_cn, health_check_cn
+
+result = update_cn()                 # raises qlib_sync.UpdateError on failure; data unchanged
+print("\n".join(result.summary_lines()))
+print(result.new_trading_days, result.added_symbols)
+```
+
+## Use it from your AI assistant
+
+qlib-sync includes an [MCP](https://modelcontextprotocol.io) server, the open standard most AI
+tools use to call local tools. Any MCP client that can start a local command works, whichever
+model it runs: Claude, GPT, Gemini, DeepSeek, Qwen, Kimi, GLM, or a local model. The server
+runs on your machine and reads the dataset there; there is no service to host and nothing
+leaves your computer. It is listed in the [MCP Registry](https://registry.modelcontextprotocol.io)
+as `io.github.randyy179/qlib-sync`.
+
+Every client needs the same two things: the command `uvx` and the arguments `qlib-sync mcp`.
+
+| Client | How to add qlib-sync |
+|---|---|
+| Claude Desktop | Download `qlib-sync.mcpb` from the [latest release](https://github.com/randyy179/qlib-sync/releases/latest) and open it |
+| Claude Code | `claude mcp add qlib-sync -- uvx qlib-sync mcp` |
+| OpenAI Codex CLI | `codex mcp add qlib-sync -- uvx qlib-sync mcp` |
+| Cursor | The JSON below, in `~/.cursor/mcp.json` |
+| Gemini CLI | The JSON below, in `~/.gemini/settings.json` |
+| Qwen Code | The JSON below, in `~/.qwen/settings.json` |
+| Tencent CodeBuddy, ByteDance Trae, Alibaba Tongyi Lingma | MCP settings, add a server manually, paste the JSON below |
+| Cherry Studio | Settings, MCP servers, add: type STDIO, command `uvx`, arguments `qlib-sync` and `mcp` on separate lines |
+| VS Code (Copilot agent mode) | `.vscode/mcp.json`: `{ "servers": { "qlib-sync": { "type": "stdio", "command": "uvx", "args": ["qlib-sync", "mcp"] } } }` |
+
+```json
+{ "mcpServers": { "qlib-sync": { "command": "uvx", "args": ["qlib-sync", "mcp"] } } }
+```
+
+Menu names and file locations change between versions; check your client's MCP documentation
+if a path above has moved. Tested with Claude Code and OpenAI Codex CLI.
+
+Web chat apps such as ChatGPT connect only to remote MCP servers over the internet, so they
+cannot start this local server.
+
+Set `QLIB_SYNC_DATA_DIR` to use a dataset outside `~/.qlib/qlib_data/cn_data`, and
+`QLIB_SYNC_MIRROR` to download through a mirror.
+
+| Tool | Does |
+|---|---|
+| `cn_status` | Local latest date, pools, and whether an update is available |
+| `cn_update` | Install or update (safe to call: failures restore the previous data) |
+| `cn_health_check` | Structure checks plus a real Qlib read |
+| `cn_get_prices` | Daily bars for up to 20 symbols; real traded prices by default, adjusted on request |
+| `cn_list_pool` | Members of csi300, csi500, and other pools on a date |
+
+Then ask things like *"Is my A-share data current? What did Moutai close at over the last
+week?"* Symbols accept `600519`, `SH600519`, or `600519.SH`.
+
+![Claude Code answering from the local dataset through qlib-sync: data freshness, Moutai closes, CSI 300 size](https://raw.githubusercontent.com/randyy179/qlib-sync/main/docs/assets/demo-claude.gif)
+
+[`skills/qlib-sync/SKILL.md`](https://github.com/randyy179/qlib-sync/blob/main/skills/qlib-sync/SKILL.md) teaches an assistant when to update,
+how to read each failure, and the price conventions. It uses the open `SKILL.md` format that
+Claude, Codex, and other agents load from their skills folder; any assistant can also simply
+be pointed at the file.
+
+## Daily updates
+
+A run that finds nothing new costs one small request, so schedule it daily. See
+[docs/scheduling.md](https://github.com/randyy179/qlib-sync/blob/main/docs/scheduling.md) for cron and launchd examples.
+
+## Data and credits
+
+All data comes from [chenditc/investment_data](https://github.com/chenditc/investment_data)
+(Apache-2.0). qlib-sync only downloads the public release; it does not host or redistribute
+data. Prices follow Qlib's convention: `$close` is adjusted and the real price is
+`$close / $factor`.
+
+qlib-sync is an independent project, not affiliated with Microsoft or the Qlib team.
+
+Supported: macOS and Linux, Python 3.10 to 3.12 (pyqlib does not publish wheels for newer
+versions yet; `uvx` picks a compatible Python automatically).
+
+## Development
+
+```bash
+uv venv && uv pip install -e ".[dev]"
+.venv/bin/python -m pytest
+```
+
+## License
+
+MIT

qlib_sync-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+qlib_sync/__init__.py,sha256=u_sxeWDHrbhaOepjl9AxrRzYMTkVP0xQVOxsJ6l5T3o,463
+qlib_sync/api.py,sha256=E-lkRm6Lp9d2i7qDoZvEuojo7tFN8mhJBQlRb37Zuyg,2126
+qlib_sync/cli.py,sha256=oia8VSrnAEn2jDMSb4PrMwhgmGC5nrp0_a-5RhnmrmE,2798
+qlib_sync/mcp_server.py,sha256=yehmniP5qJ97Hk0MOf6I35dzyXDDZt6gPI5SWJNay-0,11301
+qlib_sync/txn.py,sha256=FzkhuuTkYH29MkjQGyeSIc3MvA5djlZCInkDruLRvpE,2437
+qlib_sync/cn/__init__.py,sha256=xzDCR9NFrXYKL_NuPpzYLQs6DKodtuwudqxk5KTqPj8,46
+qlib_sync/cn/market.py,sha256=2w2rPorJ0AUaD_vHqva400DOnSNHmw2fkj8dPgMYf1E,15630
+qlib_sync/cn/update.py,sha256=cpG1GohhEDyRno5uzl07u8qw_1OuS0JGFzsDQ1Yp61M,27113
+qlib_sync-0.1.0.dist-info/METADATA,sha256=ZtIJSEZep_gc0tLjvgjmg-NBQKc9lbe1hcwML7-egMw,11193
+qlib_sync-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+qlib_sync-0.1.0.dist-info/entry_points.txt,sha256=VRZjrWdLOfOJoIEdpdzfYh6Jitg_CZCp3YEh5oWlE1Q,49
+qlib_sync-0.1.0.dist-info/licenses/LICENSE,sha256=GiKNiTcrDIfdccuBMJKFy9Ovr5COxDM4tDggWmZL-5s,1066
+qlib_sync-0.1.0.dist-info/RECORD,,

qlib_sync-0.1.0.dist-info/WHEEL

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

qlib_sync-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qlib-sync = qlib_sync.cli:main

qlib_sync-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 randyy179
+
+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.