Sequoia-X: an A-share screening pipeline that runs after the close

The problem Sequoia-X addresses for A-share traders

Screening several thousand mainland China listings by hand is not feasible, and the usual workaround is to scrape a portal. The README is explicit about why Sequoia-X avoids that route: it stores data locally and, in its own words, "彻底规避东方财富反爬问题", meaning it sidesteps the anti-scraping measures on East Money. The stated data source is baostock, described as free, requiring no registration and without rate limiting. That combination is the whole pitch. You get a local database of daily bars and a set of named technical screens, and you do not depend on a vendor's terms of service to keep reading prices.

The audience is narrow and identifiable. It is someone who trades or researches A-shares, is comfortable running a Python script on a server, and wants the result delivered as a chat message rather than as a dashboard to check. The six built-in strategies are all classical price and volume patterns: TurtleTrade (20-day breakout with turnover above 100 million and a bullish candle to filter false breakouts, sorted by gain), MaVolume, HighTightFlag, LimitUpShakeout, UptrendLimitDown, and RpsBreakout, which the README ties to O'Neil relative price strength. If none of those six describes how you pick stocks, the value drops sharply, because the project ships no strategy builder and no parameter UI.

How the pipeline works: baostock in, SQLite in the middle, Feishu out

The repository layout makes the data flow readable. main.py is only an entry point that uses argparse to dispatch between the daily and backfill modes. Everything else lives under sequoia_x, split into core (config.py for pydantic-settings, logger.py for rich output), data/engine.py, six files under strategy/, and notify/feishu.py.

The data engine is the load-bearing part. It backfills history through baostock and then keeps it current incrementally. The README states that daily updates run as 8 parallel processes and finish in two to three minutes for the whole market. The adjustment choice is worth pausing on: bars are stored 后复权, back-adjusted, with the stated reason that historical prices stay fixed, which suits incremental storage and avoids corruption around ex-rights events. That is a real engineering decision, not a default. Back-adjusted series mean the most recent bar is the one that moves when a corporate action occurs, so a locally cached row can differ from what you saw yesterday.

Storage is a single SQLite file at data/sequoia_v2.db. The README notes it can be copied to another machine directly, which is a genuine convenience for anyone who wants to develop on a laptop and run on a VPS. It also means concurrent writers are a bad idea; the cron example runs one process, and nothing documented suggests the engine coordinates across hosts.

Notification is per strategy. The .env.example shows a default FEISHU_WEBHOOK_URL plus optional per-strategy keys in the form STRATEGY_WEBHOOK_<identifier>, with unconfigured strategies falling back to the default. That is a small feature with a real use: route turtle breakouts to one group and shakeout signals to another.

Installing Sequoia-X and running a first scan

The README requires Python 3.10 or newer, which matches requires-python in pyproject.toml. Dependencies are declared normally, and the README recommends uv while also supporting pip.

uv sync

If you prefer pip, the README gives `pip install .` as the alternative. Either way you end up with pandas, baostock, akshare, pydantic-settings, python-dotenv, rich and requests installed.

Next, create the environment file. The template ships with a placeholder webhook that will not work until you replace it.

cp .env.example .env

Open .env and set FEISHU_WEBHOOK_URL to a real Feishu bot URL. The other keys have defaults: DB_PATH defaults to data/sequoia_v2.db and START_DATE to 2024-01-01. The per-strategy webhook keys are optional.

Before the first daily run you need history. The README says the backfill takes about 12 minutes for roughly 5,200 A-share symbols.

python main.py --backfill

After that, the daily command does incremental updates, runs the strategies and pushes results.

python main.py

The README estimates two to three minutes. For unattended operation it suggests a crontab entry that runs after the close on weekdays:

15 19 * * 1-5 cd /root/Sequoia-X && .venv/bin/python main.py >> log.txt 2>&1

Note the path: this assumes a virtualenv at .venv inside the project directory. If you installed with uv, confirm where the interpreter actually lives before pasting this in.

Where Sequoia-X is the wrong tool

The most important limitation is stated by the architecture itself: this is an end-of-day system. The README describes running it after the close, and the cron example fires at 19:15 on weekdays. Nothing in the repository layout or README describes a real-time quote path, an order interface, or a position manager. If your process needs an entry during the session, this project cannot supply it, and no amount of strategy editing will change that, because the data engine is built around daily baostock bars.

There is also no backtesting harness in the repository layout. The tests directory contains property tests built on hypothesis, which exercise code correctness rather than historical performance. So you cannot ask Sequoia-X whether TurtleTrade would have made money in 2023. You can only ask it which symbols match today. Anyone who treats the six strategy names as validated systems is reading more into the project than it claims.

A second practical constraint is the single SQLite file. It is convenient to copy and convenient to query, but it is not a multi-writer store. Running the daily job and an ad-hoc analysis script that writes at the same time is asking for lock contention, and the README offers no guidance on that.

Finally, the release situation. The repository shows no tagged releases and the last push was on 2026-07-10. pyproject.toml declares version 2.0.0, but there is no changelog in the repository, so upgrading means tracking the master branch and reading diffs yourself.

Sequoia-X versus akshare-based screening scripts

The interesting comparison is with the akshare route, and it is not a hypothetical one: akshare is already a declared dependency in pyproject.toml, so the project has both libraries available and still chose baostock for the price pipeline. The difference is in the operational model. akshare wraps a wide range of public endpoints, including East Money, which means broad coverage but a moving target: endpoint changes and rate limiting are recurring maintenance work. baostock gives a narrower, more stable interface with the properties the README leans on, namely no registration and no rate limit.

The trade is coverage for predictability. If you need fundamentals, sector classifications, northbound flows or intraday minute bars, baostock's daily K-line feed will not give them to you, and you would be writing akshare-based screens instead. If what you need is a stable daily bar history for the whole A-share market that you can refresh in a couple of minutes, the baostock plus SQLite combination is the more durable choice.

The other alternative is simply a hosted screener. Those give you a web interface and no server to maintain, at the cost of not owning the data or the strategy logic. Sequoia-X inverts that: you own the SQLite file and the six strategy modules, and you maintain the cron job.

Maintenance cost, licence and what to check before relying on it

The README states the licence as MIT, and pyproject.toml declares the package as sequoia-x version 2.0.0. The repository does not include a LICENSE file in its top-level entries, which is worth noting: the README's licence statement is the only licence information available. MIT is permissive, so redistribution and commercial use are normally fine, but if the licence text matters to your organisation you should treat the absence of a LICENSE file as an open question and get your own answer rather than mine.

Upgrade cost is dominated by the absence of releases. There is no version to pin against beyond the 2.0.0 in pyproject.toml, and no changelog in the repository. Practically, that means a git pull is an unreviewed change to strategy code that may alter which symbols get pushed to your Feishu group. The safer pattern is to fork, and to diff strategy/ before merging upstream.

Runtime cost is low and documented: roughly 12 minutes once for the backfill, two to three minutes per trading day afterwards, on the machine that holds the SQLite file. The recurring cost is not compute, it is the dependency on baostock's continued availability and on the Feishu webhook format, neither of which the project controls.

Editorial conclusion

Adopt Sequoia-X if you already keep a Linux box with Python 3.10 or newer and want a post-close scan of the whole A-share market without paying for a data feed. Do not adopt it if you need intraday signals, execution, backtesting with realistic fills, or a maintained library with tagged releases; the repository shows no releases and the last push was on 2026-07-10. Before trusting any signal, run python main.py --backfill, open data/sequoia_v2.db and check that the bar counts per symbol look sane for the START_DATE you set in .env.

Frequently asked questions

Official sources

1. Issues
2. README
3. sngyai/Sequoia-X on GitHub