ZVT

https://github.com/zvtvz/zvt
Admin
ZVT is a quantitative trading framework that provides tools for stock data capture, persistence,...
Tokens:32,100
Snippets:138
Trust Score:7
License:MIT
Update:11 months ago
Show doc for...
Tokens:
Raw
### ZVT Project Cloning and Setup

Source: https://github.com/zvtvz/zvt/blob/master/README.md

Instructions for cloning the ZVT project repository from GitHub and setting up the development environment. This includes installing necessary dependencies and tools like pytest for running tests.

```shell
git clone https://github.com/zvtvz/zvt.git
pip3 install -r requirements.txt
pip3 install pytest
```

--------------------------------

### Install zvt from Source

Source: https://github.com/zvtvz/zvt/blob/master/docs/source/install.rst

Installs zvt from its source code. This involves cloning the repository and then installing it locally. Use this method if you need to contribute to zvt or install a specific version from the source.

```shell
git clone git://github.com/zvtvz/zvt.git
cd zvt
python -m pip install .
```

--------------------------------

### Installing ZVT Dependencies in Python

Source: https://github.com/zvtvz/zvt/blob/master/README-cn.md

Details the commands required to set up a virtual environment for the ZVT project and install its dependencies using pip. It ensures that all necessary packages are installed for the project to run correctly.

```bash
pip3 install -r requirements.txt
pip3 install pytest
```

--------------------------------

### Install Uvicorn for ZVT Server

Source: https://github.com/zvtvz/zvt/blob/master/README.md

Installs the uvicorn package, a high-performance ASGI server, which is required for running the ZVT REST API server.

```shell
pip install uvicorn
```

--------------------------------

### ZVT Python API Example for Data and ML

Source: https://github.com/zvtvz/zvt/blob/master/README.md

Demonstrates a Python script using the ZVT library to record stock data, fetch historical k-line data, train a machine learning model, make predictions, and visualize the results. This example showcases the end-to-end capabilities of ZVT for data analysis and machine learning.

```python
>>> from zvt.domain import Stock, Stock1dHfqKdata
>>> from zvt.ml import MaStockMLMachine
>>> Stock.record_data(provider="em")
>>> entity_ids = ["stock_sz_000001", "stock_sz_000338", "stock_sh_601318"]
>>> Stock1dHfqKdata.record_data(provider="em", entity_ids=entity_ids, sleeping_time=1)
>>> machine = MaStockMLMachine(entity_ids=["stock_sz_000001"], data_provider="em")
>>> machine.train()
>>> machine.predict()
>>> machine.draw_result(entity_id="stock_sz_000001")
```

--------------------------------

### Install zvt using pip

Source: https://github.com/zvtvz/zvt/blob/master/docs/source/install.rst

Installs or upgrades the zvt package using pip. Ensure you have Python 3.7 or 3.8 installed. This is the recommended method for most users.

```shell
python -m pip install -U zvt
```

--------------------------------

### Run ZVT Server from Command Line

Source: https://github.com/zvtvz/zvt/blob/master/README.md

Starts the ZVT REST API server from the command line. This server provides API endpoints for interacting with ZVT functionalities.

```shell
zvt_server
```

--------------------------------

### Install ZVT using pip

Source: https://github.com/zvtvz/zvt/blob/master/README.md

Installs or upgrades the ZVT Python package using pip. This is the primary method for obtaining the ZVT library for use in Python projects.

```shell
python3 -m pip install -U zvt
```

--------------------------------

### Record Stock Sector Data using Specific Provider

Source: https://github.com/zvtvz/zvt/blob/master/README.md

Provides an example of recording stock sector data (blocks) for a specific provider, 'sina'. It also includes log output indicating the completion of the recording process for different block types.

```python
>>> Block.record_data(provider='sina')
Block registered recorders:{'eastmoney': <class 'zvt.recorders.eastmoney.meta.china_stock_category_recorder.EastmoneyChinaBlockRecorder'>, 'sina': <class 'zvt.recorders.sina.meta.sina_china_stock_category_recorder.SinaChinaBlockRecorder'>}
2020-03-04 23:56:48,931  INFO  MainThread  finish record sina blocks:industry
2020-03-04 23:56:49,450  INFO  MainThread  finish record sina blocks:concept
```

--------------------------------

### Example Query Result DataFrame

Source: https://github.com/zvtvz/zvt/blob/master/README-cn.md

Displays the resulting Pandas DataFrame after querying financial data. The output shows columns like 'code', 'basic_eps', 'total_op_income', 'roe', and 'timestamp', indexed by 'code'.

```python
          code  basic_eps  total_op_income    net_profit  op_income_growth_yoy  net_profit_growth_yoy     roe    rota  gross_profit_margin  net_margin  timestamp
code
000048  000048     2.7350     4.919000e+09  1.101000e+09                0.4311                 1.5168  0.7035  0.1988               0.5243      0.2355 2020-04-30
000912  000912     0.3500     4.405000e+09  3.516000e+08                0.1796                 1.2363  4.7847  0.0539               0.2175      0.0795 2019-03-20
002207  002207     0.2200     3.021000e+08  5.189000e+07                0.1600                 1.1526  1.1175  0.1182               0.1565      0.1718 2020-04-27
002234  002234     5.3300     3.276000e+09  1.610000e+09                0.8023                 3.2295  0.8361  0.5469               0.5968      0.4913 2020-04-21
002458  002458     3.7900     3.584000e+09  2.176000e+09                1.4326                 4.9973  0.8318  0.6754               0.6537      0.6080 2020-02-20
...        ...        ...              ...           ...                   ...                    ...     ...     ...                  ...         ...        ...
600701  600701    -3.6858     7.830000e+08 -3.814000e+09                1.3579                -0.0325  1.9498 -0.7012               0.4173     -4.9293 2020-04-29
600747  600747    -1.5600     3.467000e+08 -2.290000e+09                2.1489                -0.4633  3.1922 -1.5886               0.0378     -6.6093 2020-06-30
600793  600793     1.6568     1.293000e+09  1.745000e+08                0.1164                 0.8868  0.7490  0.0486               0.1622      0.1350 2019-04-30
600870  600870     0.0087     3.096000e+07  4.554000e+06                0.7773                 1.3702  0.7458  0.0724               0.2688      0.1675 2019-03-30
688169  688169    15.6600     4.205000e+09  7.829000e+08                0.3781                 1.5452  0.7172  0.4832               0.3612      0.1862 2020-04-28

[20 rows x 11 columns]
```

--------------------------------

### Querying Financial Data with Filters

Source: https://github.com/zvtvz/zvt/blob/master/README-cn.md

This example demonstrates how to query financial data, specifically filtering for stocks with high ROE and revenue growth in their 2018 annual reports. It uses `query_data` with multiple filters, ordering, limiting results, and selecting specific columns.

```python
>>> df=FinanceFactor.query_data(filters=[FinanceFactor.roe>0.08,FinanceFactor.report_period=='year',FinanceFactor.op_income_growth_yoy>0.08],start_timestamp='2019-01-01',order=FinanceFactor.roe.desc(),limit=20,columns=["code"]+FinanceFactor.important_cols(),index='code')
```

--------------------------------

### Query ZVT REST API using Python Requests

Source: https://context7.com/zvtvz/zvt/llms.txt

Demonstrates how to interact with the ZVT REST API server using the Python 'requests' library. It shows examples for fetching data providers, schemas, querying stock data, factor results, and K-line data. Requires the ZVT server to be running.

```python
# Start server from command line
# $ zvt_server
# Server runs at http://127.0.0.1:8090
# API docs at http://127.0.0.1:8090/docs

import requests
import json

# Base URL
base_url = "http://127.0.0.1:8090"

# 1. Get available data providers
response = requests.get(f"{base_url}/api/data/providers")
providers = response.json()
print(f"Available providers: {providers}")

# 2. Get schemas for a provider
response = requests.get(f"{base_url}/api/data/schemas?provider=em")
schemas = response.json()
print(f"Schemas: {schemas[:5]}")

# 3. Query data from schema
response = requests.get(
    f"{base_url}/api/data/query_data?provider=em&schema=Stock"
)
stocks = response.json()
print(f"First stock: {stocks[0]}")

# 4. Query factor results
factor_request = {
    "factor_name": "MacdFactor",
    "codes": ["000001", "000338"],
    "start_timestamp": "2021-01-01",
    "end_timestamp": "2021-12-31",
    "level": "1d",
    "provider": "em"
}

response = requests.post(
    f"{base_url}/api/factor/query_factor_result",
    json=factor_request
)
factor_result = response.json()
print(f"Factor signals: {factor_result}")

# 5. Query K-line data
kdata_request = {
    "entity_ids": ["stock_sz_000001"],
    "start_timestamp": "2021-01-01",
    "end_timestamp": "2021-12-31",
    "level": "1d",
    "provider": "em"
}

response = requests.post(
    f"{base_url}/api/trading/query_kdata",
    json=kdata_request
)
kdata = response.json()
print(f"K-data records: {len(kdata)}")
```

--------------------------------

### Query High Income Countries (Python)

Source: https://github.com/zvtvz/zvt/blob/master/docs/source/data/trading_anything.rst

Demonstrates how to query and filter 'Country' entities using ZVT's domain API. This example retrieves all country data and then filters for countries with an 'income_level' of 'High income'.

```python
>>> from zvt.domain import Country
>>> Country.record_data()
>>> df = Country.query_data()
>>> df[df['income_level']=='High income']
```

--------------------------------

### Record and Query China Stock Data (Python)

Source: https://github.com/zvtvz/zvt/blob/master/README.md

This Python code snippet demonstrates how to record and query Chinese stock data using the zvt library. It imports necessary domain models, records data from the 'em' provider, and then queries and prints the data indexed by stock code. This function requires the zvt library to be installed.

```python
from zvt.domain import *
Stock.record_data(provider="em")
df = Stock.query_data(provider="em", index='code')
print(df)
```

--------------------------------

### Record and Query US Stock Data using ZVT Python

Source: https://github.com/zvtvz/zvt/blob/master/docs/source/data/data_concepts.rst

Illustrates recording and querying data for US stocks (Stockus) with the ZVT library. Similar to the China stock example, it imports Stockus, records data, and then queries it into a DataFrame for display. The output reflects US stock information.

```python
from zvt.domain import Stockus
Stockus.record_data()
df = Stockus.query_data()
print(df)
```

--------------------------------

### Record and Query Specific Kdata with ZVT

Source: https://github.com/zvtvz/zvt/blob/master/docs/source/data/data_concepts.rst

Provides an example of recording and querying specific Kdata for a given security code and provider. This snippet focuses on a single entity and uses the Stock1dHfqKdata schema. It requires importing the specific Kdata schema from zvt.domain.

```python
from zvt.domain import Stock1dHfqKdata
Stock1dHfqKdata.record_data(code='000338', provider='em')
df = Stock1dHfqKdata.query_data(code='000338', provider='em')
```

--------------------------------

### Record and Query US Stock Data (Python)

Source: https://github.com/zvtvz/zvt/blob/master/README-cn.md

This snippet demonstrates how to record US stock data and then query it. It shows querying by index ('code') to get a DataFrame of all US stocks and also querying for a specific stock code ('AAPL'). It relies on a 'Stockus' class with 'record_data' and 'query_data' methods.

```python
>>> Stockus.record_data()
>>> df = Stockus.query_data(index='code')
>>> print(df)

                       id            entity_id timestamp entity_type exchange  code                         name list_date end_date
code
A          stockus_nyse_A       stockus_nyse_A       NaT     stockus     nyse     A                          安捷伦      None     None
AA        stockus_nyse_AA      stockus_nyse_AA       NaT     stockus     nyse    AA                         美国铝业      None     None
AAC      stockus_nyse_AAC     stockus_nyse_AAC       NaT     stockus     nyse   AAC      Ares Acquisition Corp-A      None     None
AACG  stockus_nasdaq_AACG  stockus_nasdaq_AACG       NaT     stockus   nasdaq  AACG    ATA Creativity Global ADR      None     None
AACG    stockus_nyse_AACG    stockus_nyse_AACG       NaT     stockus     nyse  AACG    ATA Creativity Global ADR      None     None
...                   ...                  ...       ...         ...      ...   ...                          ...       ...      ...
ZWRK  stockus_nasdaq_ZWRK  stockus_nasdaq_ZWRK       NaT     stockus   nasdaq  ZWRK    Z-Work Acquisition Corp-A      None     None
ZY      stockus_nasdaq_ZY    stockus_nasdaq_ZY       NaT     stockus   nasdaq    ZY                 Zymergen Inc      None     None
ZYME    stockus_nyse_ZYME    stockus_nyse_ZYME       NaT     stockus     nyse  ZYME                Zymeworks Inc      None     None
ZYNE  stockus_nasdaq_ZYNE  stockus_nasdaq_ZYNE       NaT     stockus   nasdaq  ZYNE  Zynerba Pharmaceuticals Inc      None     None
ZYXI  stockus_nasdaq_ZYXI  stockus_nasdaq_ZYXI       NaT     stockus   nasdaq  ZYXI                    Zynex Inc      None     None

[5826 rows x 9 columns]

>>> Stockus.query_data(code='AAPL')
                    id            entity_id timestamp entity_type exchange  code name list_date end_date
0  stockus_nasdaq_AAPL  stockus_nasdaq_AAPL      None     stockus   nasdaq  AAPL   苹果      None     None
```

--------------------------------

### Record and Query Hong Kong Stock Data using ZVT Python

Source: https://github.com/zvtvz/zvt/blob/master/docs/source/data/data_concepts.rst

Provides a Python example using ZVT to record and query data for Hong Kong stocks (Stockhk). It imports the Stockhk class, records data, and then queries it using the 'code' as the index for the resulting DataFrame. The output displays Hong Kong stock details.

```python
from zvt.domain import Stockhk
Stockhk.record_data()
df = Stockhk.query_data(index='code')
print(df)
```

--------------------------------

### Record and Query Domestic Stock Data (Python)

Source: https://github.com/zvtvz/zvt/blob/master/README.md

Provides Python examples for recording and querying daily historical data for a domestic stock (e.g., '000338'). It utilizes `Stock1dKdata` to fetch data from a specified provider and prints the resulting Pandas DataFrame.

```python
>>> Stock1dKdata.record_data(code='000338', provider='em')
>>> df = Stock1dKdata.query_data(code='000338', provider='em')
>>> print(df)
```

--------------------------------

### Query Hong Kong Stock Data with ZVT

Source: https://github.com/zvtvz/zvt/blob/master/README-cn.md

This snippet shows how to record and query trading data for Hong Kong stocks using the `Stockhk` class from the ZVT library. It demonstrates fetching all records and then filtering for a specific stock code. Assumes ZVT library is installed and `Stockhk` is available.

```python
>>> Stockhk.record_data()
>>> df = Stockhk.query_data(index='code')
>>> print(df)

                     id         entity_id timestamp entity_type exchange   code    name list_date end_date
code
00001  stockhk_hk_00001  stockhk_hk_00001       NaT     stockhk       hk  00001      长和      None     None
00002  stockhk_hk_00002  stockhk_hk_00002       NaT     stockhk       hk  00002    中电控股      None     None
00003  stockhk_hk_00003  stockhk_hk_00003       NaT     stockhk       hk  00003  香港中华煤气      None     None
00004  stockhk_hk_00004  stockhk_hk_00004       NaT     stockhk       hk  00004   九龙仓集团      None     None
00005  stockhk_hk_00005  stockhk_hk_00005       NaT     stockhk       hk  00005    汇丰控股      None     None
...                 ...               ...       ...         ...      ...    ...     ...       ...      ...
09996  stockhk_hk_09996  stockhk_hk_09996       NaT     stockhk       hk  09996  沛嘉医疗-B      None     None
09997  stockhk_hk_09997  stockhk_hk_09997       NaT     stockhk       hk  09997    康基医疗      None     None
09998  stockhk_hk_09998  stockhk_hk_09998       NaT     stockhk       hk  09998    光荣控股      None     None
09999  stockhk_hk_09999  stockhk_hk_09999       NaT     stockhk       hk  09999    网易-S      None     None
80737  stockhk_hk_80737  stockhk_hk_80737       NaT     stockhk       hk  80737  湾区发展-R      None     None

[2597 rows x 9 columns]

>>> df[df.code=='00700']

                    id         entity_id timestamp entity_type exchange   code  name list_date end_date
2112  stockhk_hk_00700  stockhk_hk_00700      None     stockhk       hk  00700  腾讯控股      None     None
```

--------------------------------

### Record and Query USA Stock Data (Python)

Source: https://github.com/zvtvz/zvt/blob/master/README.md

This Python code snippet shows how to record and query US stock data using the zvt library. It utilizes the Stockus class to record data and then query it, either by indexing all stocks by code or by fetching data for a specific stock code like 'AAPL'. The zvt library must be installed to run this code.

```python
Stockus.record_data()
df = Stockus.query_data(index='code')
print(df)

Stockus.query_data(code='AAPL')
```

--------------------------------

### Stock Target Selection using TargetSelector and Factors in Python

Source: https://github.com/zvtvz/zvt/blob/master/docs/source/factor/factor_concepts.rst

This example shows how to use the TargetSelector class to filter stocks based on specified factors. It involves initializing a TargetSelector, adding a CrossMaFactor to it, running the selection process, and printing the DataFrame of stocks that meet the criteria for opening long positions. Dependencies include zvt.contract, zvt.factors, and zvt.factors.ma.ma_factor.

```python
from zvt.contract import IntervalLevel
from zvt.factors.target_selector import TargetSelector
from zvt.factors.ma.ma_factor import CrossMaFactor

entity_ids = ["stock_sz_000338"]
entity_type = "stock"
start_timestamp = "2018-01-01"
end_timestamp = "2019-06-30"
my_selector = TargetSelector(
    entity_ids=entity_ids, entity_schema=entity_type, start_timestamp=start_timestamp, end_timestamp=end_timestamp
)

my_selector.add_factor(
    CrossMaFactor(
        entity_provider="em",
        provider="em",
        entity_ids=entity_ids,
        start_timestamp=start_timestamp,
        end_timestamp=end_timestamp,
        computing_window=10,
        windows=[5, 10],
        need_persist=False,
        level=IntervalLevel.LEVEL_1DAY,
        adjust_type="hfq",
    )
)
my_selector.run()
print(my_selector.open_long_df)
```

--------------------------------

### Implement Bollinger Bands Transformer and Factor using TA-Lib

Source: https://github.com/zvtvz/zvt/blob/master/docs/source/factor/extending_factor.rst

This snippet shows how to create a custom Transformer for Bollinger Bands using the 'ta' library and integrate it into a ZVT Factor. It includes the installation of the 'ta' library, the implementation of the BollTransformer class, and the BollFactor class which utilizes the transformer and defines how to compute results and visualize the factor.

```python
from typing import Optional, List

import pandas as pd
from ta.volatility import BollingerBands

from zvt.contract.factor import *
from zvt.factors import TechnicalFactor


class BollTransformer(Transformer):
    def transform_one(self, entity_id, df: pd.DataFrame) -> pd.DataFrame:
        indicator_bb = BollingerBands(close=df["close"], window=20, window_dev=2)

        # Add Bollinger Bands features
        df["bb_bbm"] = indicator_bb.bollinger_mavg()
        df["bb_bbh"] = indicator_bb.bollinger_hband()
        df["bb_bbl"] = indicator_bb.bollinger_lband()

        # Add Bollinger Band high indicator
        df["bb_bbhi"] = indicator_bb.bollinger_hband_indicator()

        # Add Bollinger Band low indicator
        df["bb_bbli"] = indicator_bb.bollinger_lband_indicator()

        # Add Width Size Bollinger Bands
        df["bb_bbw"] = indicator_bb.bollinger_wband()

        # Add Percentage Bollinger Bands
        df["bb_bbp"] = indicator_bb.bollinger_pband()
        return df


class BollFactor(TechnicalFactor):
    transformer = BollTransformer()

    def drawer_factor_df_list(self) -> Optional[List[pd.DataFrame]]:
        # set the factor to show
        return [self.factor_df[["bb_bbm", "bb_bbh", "bb_bbl"]]]

    def compute_result(self):
        # set filter_result, which bb_bbli=1.0 buy and bb_bbhi=1.0 sell
        super().compute_result()
        self.result_df = (self.factor_df["bb_bbli"] - self.factor_df["bb_bbhi"]).to_frame(name="filter_result")
        self.result_df[self.result_df == 0] = None
        self.result_df[self.result_df == 1] = True
        self.result_df[self.result_df == -1] = False

# install ta at first:
# pip install --upgrade ta
```

--------------------------------

### Calculate Technical Factors with ZVT

Source: https://github.com/zvtvz/zvt/blob/master/README.md

This Python code demonstrates how to use the ZVT library to calculate technical factors for multiple entities. It shows the instantiation of a `BullFactor` with a `MacdTransformer` to process historical stock data. The example involves specifying stock codes, a date range, and a transformer, then accessing the resulting two-dimensional index DataFrame (`data_df`) which contains the calculated factor values.

```python
from zvt.factors import *
factor = BullFactor(codes=['000338','601318'],start_timestamp='2019-01-01',end_timestamp='2019-06-10', transformer=MacdTransformer(count_live_dead=True))
```

--------------------------------

### Initializing ZVT Configuration in Python

Source: https://github.com/zvtvz/zvt/blob/master/README-cn.md

Demonstrates how to initialize the ZVT configuration, including setting up credentials for data providers like 'jq' (Juque). It shows the default environment variables and configuration parameters, allowing users to customize settings for data paths and API access.

```python
>>> from zvt import *
>>> zvt_env
{'zvt_home': '/Users/foolcage/zvt-home',
 'data_path': '/Users/foolcage/zvt-home/data',
 'tmp_path': '/Users/foolcage/zvt-home/tmp',
 'ui_path': '/Users/foolcage/zvt-home/ui',
 'log_path': '/Users/foolcage/zvt-home/logs'}

>>> zvt_config 

# jq_username 聚宽数据用户名
# jq_password 聚宽数据密码
# smtp_host 邮件服务器host
# smtp_port 邮件服务器端口
# email_username smtp邮箱账户
# email_password smtp邮箱密码
# wechat_app_id
# wechat_app_secrect

>>> init_config(current_config=zvt_config, jq_username='xxx', jq_password='yyy')

> 通用的配置方式为: init_config(current_config=zvt_config, **kv)
```

--------------------------------

### Initialize ZVT Environment and Configuration

Source: https://context7.com/zvtvz/zvt/llms.txt

Shows how to initialize the ZVT environment, setting a custom home directory and configuring various services. This includes setting up JoinQuant credentials, email alerts via SMTP, and WeChat notifications. The `init_env` function returns a dictionary of environment paths, while `init_config` updates global ZVT configuration.

```python
from zvt import init_env, init_config, zvt_env, zvt_config
import pprint

# Initialize environment with custom home directory
zvt_env = init_env(zvt_home='/home/user/my-zvt-data')
pprint.pprint(zvt_env)

# Configure data provider credentials
init_config(
    current_config=zvt_config,
    jq_username='your_joinquant_username',
    jq_password='your_joinquant_password'
)

# Configure email alerts
init_config(
    current_config=zvt_config,
    smtp_host='smtp.gmail.com',
    smtp_port=587,
    email_username='your_email@gmail.com',
    email_password='your_app_password'
)

# Configure WeChat notifications
init_config(
    current_config=zvt_config,
    wechat_app_id='your_wechat_app_id',
    wechat_app_secrect='your_wechat_app_secret'
)
```

--------------------------------

### ZVT Environment Settings and Initialization

Source: https://github.com/zvtvz/zvt/blob/master/README.md

This snippet shows how to view the current ZVT environment settings and how to initialize the configuration with specific parameters, such as data provider credentials. It demonstrates accessing global environment variables and applying custom configurations.

```python
from zvt import *
print(zvt_env)
print(zvt_config)
init_config(current_config=zvt_config, jq_username='xxx', jq_password='yyy')
```

--------------------------------

### Implement WBCountryRecorder (Python)

Source: https://github.com/zvtvz/zvt/blob/master/docs/source/data/trading_anything.rst

Implements a data recorder for the 'Country' entity using the 'wb' provider. The `run` method fetches country data using `wb_api.get_countries()` and persists it to the database via `df_to_db`.

```python
from zvt.contract.api import df_to_db
from zvt.contract.recorder import Recorder
from zvt.domain.meta.country_meta import Country
from zvt.recorders.wb import wb_api


class WBCountryRecorder(Recorder):
    provider = "wb"
    data_schema = Country

    def run(self):
        df = wb_api.get_countries()
        df_to_db(df=df, data_schema=self.data_schema, provider=self.provider, force_update=self.force_update)
```

--------------------------------

### Compute and Draw BollFactor

Source: https://github.com/zvtvz/zvt/blob/master/docs/source/factor/extending_factor.rst

This code snippet shows how to initialize and draw a BollFactor. It takes entity IDs, provider information, and an optional start timestamp. The `draw` method visualizes the computed factor.

```python
from zvt.factors import BollFactor

entity_ids = ["stock_sz_000338", "stock_sh_601318"]
provider = "em"

factor = BollFactor(
    entity_ids=entity_ids, provider=provider, entity_provider=provider, start_timestamp="2021-01-01"
)
factor.draw(show=True)
```

--------------------------------

### Record Data for a Schema

Source: https://github.com/zvtvz/zvt/blob/master/README.md

Illustrates the unified way to record data for any schema using the Schema.record_data() method. It highlights the optional 'provider' parameter for specifying data sources and mentions that the first provider is used by default.

```python
Schema.record_data(provider='your provider',codes='the codes')
```

--------------------------------

### Get ZVT Schema Storage Engines

Source: https://github.com/zvtvz/zvt/blob/master/docs/source/data/data_concepts.rst

Shows how to retrieve the storage engines associated with a specific ZVT schema. This is useful for understanding where the data is stored, typically in local SQLite databases. It depends on ZVT schema classes.

```python
from zvt.domain import Stock1dHfqKdata
print(Stock1dHfqKdata.get_storages())
```

--------------------------------

### Displaying result_df Data in Python

Source: https://github.com/zvtvz/zvt/blob/master/README-cn.md

Illustrates the result_df DataFrame, which is a 2D indexed DataFrame suitable for stock selection. It's generated by computing on data_df or factor_df. This example shows how MACD is used, with True values when the yellow and white lines are above the 0 axis.

```python
In [14]: factor.result_df
Out[14]:
                            score
entity_id       timestamp
stock_sh_601318 2019-01-02  False
                2019-01-03  False
                2019-01-04  False
                2019-01-07  False
                2019-01-08  False
...                           ...
stock_sz_000338 2019-06-03  False
                2019-06-04  False
                2019-06-05  False
                2019-06-06  False
                2019-06-10  False

[208 rows x 1 columns]
```

--------------------------------

### Initialize and Train ML Machine with Moving Average Features

Source: https://context7.com/zvtvz/zvt/llms.txt

Initializes a MaStockMLMachine with specified entity IDs and data range, trains the model, and prints the training score. It then generates predictions, prints their shape, and visualizes the results, saving the plot to a file. Finally, it accesses and prints the tail of the prediction DataFrame, showing close prices, predictions, and errors.

```python
from zvt import init_env, init_config, zvt_env, zvt_config
from zvt.factors.moving_average import MaStockMLMachine
import matplotlib.pyplot as plt

# Initialize ML machine with moving average features
machine = MaStockMLMachine(
    entity_ids=["stock_sz_000001"],
    data_provider="em",
    start_timestamp='2015-01-01',
    end_timestamp='2021-12-31'
)

# Train the model
machine.train()
print(f"Model training completed. Score: {machine.score}")

# Make predictions
predictions = machine.predict()
print(f"Predictions shape: {predictions.shape}")

# Visualize results
machine.draw_result(entity_id="stock_sz_000001")
plt.savefig('prediction_result.png')

# Access prediction DataFrame
df_pred = machine.result_df
print(df_pred[['close', 'prediction', 'error']].tail())
```

--------------------------------

### Query K-line Data with Different Adjustments and Intervals

Source: https://context7.com/zvtvz/zvt/llms.txt

Demonstrates how to query K-line data for stocks at various time intervals (daily, 5-minute, 1-hour, weekly) and with different adjustment types (pre-adjusted, post-adjusted, not adjusted). It also shows how to print available interval levels.

```python
from zvt.domain import Stock1dKdata, Stock1dHfqKdata, Stock1dBfqKdata
from zvt.domain import Stock5mKdata, Stock1hKdata, Stock1wkKdata
from zvt.contract import IntervalLevel, AdjustType

# Daily data with different adjustment types
# qfq (前复权): Pre-adjusted - default
Stock1dKdata.record_data(code='000338', provider='em')

# hfq (后复权): Post-adjusted
Stock1dHfqKdata.record_data(code='000338', provider='em')

# bfq (不复权): Not adjusted
Stock1dBfqKdata.record_data(code='000338', provider='em')

# Query with comparison
df_qfq = Stock1dKdata.query_data(code='000338', limit=1)
df_hfq = Stock1dHfqKdata.query_data(code='000338', limit=1)
print(f"Pre-adjusted close: {df_qfq.iloc[0]['close']}")
print(f"Post-adjusted close: {df_hfq.iloc[0]['close']}")

# Intraday data at different intervals
# 5-minute K-line
Stock5mKdata.record_data(code='000338', provider='em')

# 1-hour K-line
Stock1hKdata.record_data(code='000338', provider='em')

# Weekly K-line
Stock1wkKdata.record_data(code='000338', provider='em')

# Available intervals
for level in IntervalLevel:
    print(level.value)
# Output: tick, 1m, 5m, 15m, 1h, 1d, 1wk, 1mon
```

--------------------------------

### Run ZVT Dash & Plotly UI

Source: https://github.com/zvtvz/zvt/blob/master/README.md

Launches the ZVT Dash & Plotly user interface from the command line. This UI is suitable for backtesting and research purposes and can be accessed via a web browser.

```shell
zvt
```

--------------------------------

### Inspect Schema Fields with .help()

Source: https://github.com/zvtvz/zvt/blob/master/README.md

Demonstrates how to use the .help() method on a schema to display its fields and understand their meaning. This is a crucial step for data exploration and understanding the structure of ZVT data.

```python
>>> FinanceFactor.help()
```

--------------------------------

### Access ZVT Global Context and Registry

Source: https://context7.com/zvtvz/zvt/llms.txt

Demonstrates how to query registered schemas, providers, and database engines within the ZVT context. It shows how to retrieve all tradable entity types, all registered schemas, provider-to-recorder mappings for specific domains like 'Stock', and database engines for specific providers.

```python
from zvt.contract import zvt_context
import pprint

# Get all tradable entity types
pprint.pprint(zvt_context.tradable_schema_map)

# Get all registered schemas
all_schemas = zvt_context.schemas
print(f"Total schemas: {len(all_schemas)}")
print(f"Sample schemas: {[s.__name__ for s in all_schemas[:5]]}")

# Get provider-to-recorder mapping for Stock
from zvt.domain import Stock
pprint.pprint(Stock.provider_map_recorder)

# Get database engine for specific provider
from zvt.contract.api import get_db_engine
engine = get_db_engine(provider='em', data_schema=Stock)
print(f"Database engine: {engine.url}")
```

--------------------------------

### Access Open Short DataFrame and Get Open Long Targets

Source: https://github.com/zvtvz/zvt/blob/master/docs/source/factor/factor_concepts.rst

This snippet demonstrates how to access an open short DataFrame and retrieve open long targets for a specific date. It assumes the existence of a `my_selector` object with these methods. The `get_open_long_targets` function allows for timestamp-based target selection.

```python
print(my_selector.open_short_df)
my_selector.get_open_long_targets("2019-06-27")
```

--------------------------------

### Import Core ZVT Concepts

Source: https://github.com/zvtvz/zvt/blob/master/README-cn.md

Imports all core domain models from the ZVT library, making them readily available for use in your quantitative trading scripts.

```python
>>> from zvt.domain import *
```

--------------------------------

### View ZVT Configuration

Source: https://context7.com/zvtvz/zvt/llms.txt

Displays the current configuration settings for the ZVT project. This includes details like usernames, passwords (masked), and SMTP server information.

```python
import pprint

pprint.pprint(zvt_config)
```

--------------------------------

### Implement Stock News Recorder

Source: https://github.com/zvtvz/zvt/blob/master/docs/source/data/extending_data.rst

This Python code snippet shows the beginning of implementing a data recorder for stock news using zvt's FixedCycleDataRecorder. It imports necessary modules like pandas and zvt components, defines the recorder class inheriting from FixedCycleDataRecorder, and sets an example original page URL.

```python
import pandas as pd
from zvt.contract.api import df_to_db
from zvt.contract.recorder import FixedCycleDataRecorder
from zvt.domain import Stock
from zvt.domain.misc.stock_news import StockNews
from zvt.recorders.em import em_api


class EMStockNewsRecorder(FixedCycleDataRecorder):
    original_page_url = "https://wap.eastmoney.com/quote/stock/0.002572.html"
```

--------------------------------

### Cloning ZVT Project Repository

Source: https://github.com/zvtvz/zvt/blob/master/README-cn.md

Provides the command to clone the ZVT project from its GitHub repository. This is the first step for developers who want to contribute to the project or use its codebase locally.

```bash
git clone https://github.com/zvtvz/zvt.git
```

--------------------------------

### Check Available Data Providers for Stock Schema

Source: https://github.com/zvtvz/zvt/blob/master/README.md

Shows how to inspect the 'provider_map_recorder' attribute of a schema (e.g., Stock) to see all implemented data providers. This is useful for understanding data sourcing options and selecting a specific provider.

```python
>>> Stock.provider_map_recorder
{'joinquant': zvt.recorders.joinquant.meta.jq_stock_meta_recorder.JqChinaStockRecorder,
 'exchange': zvt.recorders.exchange.exchange_stock_meta_recorder.ExchangeStockMetaRecorder,
 'em': zvt.recorders.em.meta.em_stock_meta_recorder.EMStockRecorder,
 'eastmoney': zvt.recorders.eastmoney.meta.eastmoney_stock_meta_recorder.EastmoneyChinaStockListRecorder}
```

--------------------------------

### Record and Query ZVT Schema Data

Source: https://github.com/zvtvz/zvt/blob/master/docs/source/data/data_concepts.rst

Demonstrates how to record and query data using ZVT schemas. It shows importing schemas, recording data for specific entity IDs with a given provider, and querying data into a pandas DataFrame. Dependencies include zvt.domain and pandas.

```python
from zvt.domain import *
entity_ids = ["stock_sz_000338", "stock_sz_000001"]
Stock1dHfqKdata.record_data(entity_ids=entity_ids, provider="em")
df = Stock1dHfqKdata.query_data(entity_ids=entity_ids, provider="em")
print(df)
```

--------------------------------

### Compare Financial Indices using ZVT

Source: https://github.com/zvtvz/zvt/blob/master/docs/source/drawer/drawer_concepts.rst

This code snippet demonstrates how to compare different financial indices using the `compare` function from ZVT's intent module. It involves recording data for indices and then calling the compare function with specified entity IDs and a start timestamp. The comparison can be customized with schema mapping for different data types.

```python
from zvt.api.intent import compare
from zvt.domain import Indexus1dKdata, Index, Indexus, Index1dKdata

Index.record_data(provider="em")
Indexus.record_data(provider="em")
Index1dKdata.record_data(entity_id="index_sh_000001", provider="em")
Indexus1dKdata.record_data(entity_id="indexus_us_SPX", provider="em")

compare(entity_ids=["index_sh_000001", "indexus_us_SPX"], start_timestamp="2000-01-01", scale_value=100)
```

```python
compare(entity_ids=["index_sh_000001", "indexus_us_SPX"], start_timestamp="2000-01-01",  schema_map_columns={Index1dKdata:["close"],Indexus1dKdata:["close"]})
```

--------------------------------

### Recording Stock Block Data using Sina Provider

Source: https://github.com/zvtvz/zvt/blob/master/README-cn.md

Shows how to record stock block data (e.g., industry, concept) using a specific provider ('sina'). The output indicates the progress and completion of data recording for different block types.

```python
>>> Block.provider_map_recorder
{'eastmoney': zvt.recorders.eastmoney.meta.china_stock_category_recorder.EastmoneyChinaBlockRecorder, 'sina': zvt.recorders.sina.meta.sina_block_recorder.SinaBlockRecorder}
>>> Block.record_data(provider='sina')
Block registered recorders:{'eastmoney': <class 'zvt.recorders.eastmoney.meta.china_stock_category_recorder.EastmoneyChinaBlockRecorder'>, 'sina': <class 'zvt.recorders.sina.meta.sina_china_stock_category_recorder.SinaChinaBlockRecorder'>}
2020-03-04 23:56:48,931  INFO  MainThread  finish record sina blocks:industry
2020-03-04 23:56:49,450  INFO  MainThread  finish record sina blocks:concept
```

--------------------------------

### Record and Query A-Share Stock Data (Python)

Source: https://github.com/zvtvz/zvt/blob/master/README-cn.md

This snippet shows how to record new A-share stock data and then query it, displaying the results as a Pandas DataFrame. It assumes the existence of a 'Stock' class with 'record_data' and 'query_data' methods. The query result is indexed by 'code'.

```python
>>> Stock.record_data()
>>> df = Stock.query_data(index='code')
>>> print(df)

                     id        entity_id  timestamp entity_type exchange    code   name  list_date end_date
code
000001  stock_sz_000001  stock_sz_000001 1991-04-03       stock       sz  000001   平安银行 1991-04-03     None
000002  stock_sz_000002  stock_sz_000002 1991-01-29       stock       sz  000002  万  科Ａ 1991-01-29     None
000004  stock_sz_000004  stock_sz_000004 1990-12-01       stock       sz  000004   国华网安 1990-12-01     None
000005  stock_sz_000005  stock_sz_000005 1990-12-10       stock       sz  000005   世纪星源 1990-12-10     None
000006  stock_sz_000006  stock_sz_000006 1992-04-27       stock       sz  000006   深振业Ａ 1992-04-27     None
...                 ...              ...        ...         ...      ...     ...    ...        ...      ...
605507  stock_sh_605507  stock_sh_605507 2021-08-02       stock       sh  605507   国邦医药 2021-08-02     None
605577  stock_sh_605577  stock_sh_605577 2021-08-24       stock       sh  605577   龙版传媒 2021-08-24     None
605580  stock_sh_605580  stock_sh_605580 2021-08-19       stock       sh  605580   恒盛能源 2021-08-19     None
605588  stock_sh_605588  stock_sh_605588 2021-08-12       stock       sh  605588   冠石科技 2021-08-12     None
605589  stock_sh_605589  stock_sh_605589 2021-08-10       stock       sh  605589   圣泉集团 2021-08-10     None

[4136 rows x 9 columns]
```

--------------------------------

### Record Historical Adjusted Stock Data (1D K-line) in Python

Source: https://github.com/zvtvz/zvt/blob/master/README-cn.md

This example shows how to record historical daily (1D) K-line data with backward adjustment (后复权) for a Chinese stock. It utilizes the Stock1dHfqKdata class, specifying the stock code and data provider. This is essential for analyzing stock price trends adjusted for corporate actions like stock splits and dividends.

```python
Stock1dHfqKdata.record_data(code='000338', provider='em')
```
Tokens:
Raw