repository·master·Indexed 26 days ago
https://github.com/zvtvz/zvtA comprehensive quantitative trading framework for data capture, machine learning-based prediction, and strategy backtesting and execution. ZVT supports multiple markets including China, USA, and HK, providing a Dash & Plotly UI for research and a scalable REST API for real-time trading. It features a unified interface for recording and querying market data across various asset classes (Stocks, Indices, ETFs, Funds) and supports a three-step factor calculation model (data_df, factor_df, result_df) for formal strategy development.
The Trader facility is a tool designed for backtesting and generating trading signals. It supports several built-in strategies and allows for custom implementations. You can use it with:
FactorTargetSelectorMLMachineZVT abstracts the market into three core components that form its market model:
In zvt, data is modeled through two primary types of entities. Data itself is defined as the events that occur on these entities:
Understanding this distinction is fundamental to how data is structured and queried within the system.
zvt, a factor is defined as data describing the market. Factors are computed from an existing Schema and can be saved as a new Schema if necessary. This abstraction provides a unified way to handle quantitative market data.In zvt, data visualization and analysis are driven by 'intent'. The system classifies intents into three primary categories:
Different intents use different data structures, such as NormalData, to express their specific analytical goals.
ZVT is built around several key domain concepts for market data and trading:
5m, 1d).sqlite, mysql).Schema.Schema. Factors can be saved as new Schemas.Factor.TargetSelector, MLMachine, or a custom freestyle approach.TradableEntity across different dimensions, often used as features for ML categories.compare, distribute, or composite.Trader is the core backtest engine in zvt. It can be configured to execute strategies using one of three modes: TargetSelector, MLMachine, or a custom "free style" implementation.zvt uses a SQL database (defaulting to SQLite) to store data and provides a uniform API for recording and querying. Data is organized around entities (like TradableEntity or ActorEntity) and the events that happen to them.
An entity is defined by:
entity_type: The type of entity (e.g., stock, future, bond).exchange: The exchange where the entity is traded.code: The entity's symbol/code.The unique entity_id is constructed as: {entity_type}_{exchange}_{code}.
Common data fields include:
entity_id: The unique identifier for the entity.timestamp: The time the event occurred.id: The unique record ID, typically formatted as {entity_id}_{timestamp}.To add a new type of entity (e.g., a Country), create a class that inherits from TradableEntity and a SQLAlchemy declarative_base. Use the @register_entity decorator with an entity_type to identify the entity. Finally, call register_schema to link the entity to specific providers and a database name.
An entity is uniquely identified by its entity_type, exchange, and code (e.g., entity_type='country', exchange='galaxy', code='CN').
from sqlalchemy import Column, String, Float
from sqlalchemy.orm import declarative_base
from zvt.contract.schema import TradableEntity
from zvt.contract.register import register_schema, register_entity
CountryMetaBase = declarative_base()
@register_entity(entity_type="country")
class Country(CountryMetaBase, TradableEntity):
__tablename__ = "country"
region = Column(String(length=128))
capital_city = Column(String(length=128))
income_level = Column(String(length=64))
lending_type = Column(String(length=64))
longitude = Column(Float)
latitude = Column(Float)
register_schema(providers=["wb"], db_name="country_meta", schema_base=CountryMetaBase)A Transformer is a stateless object used to manipulate NormalData. To implement one, override the transform_one method to process a single entity's DataFrame.
Note: transform_one is ideal for libraries that calculate single targets. If you need to calculate multiple targets simultaneously for better performance, you can implement the transform method directly.
To add a new TradableEntity to zvt, follow these four steps:
TradableEntity. Use the @register_entity decorator to specify the entity_type. Use register_schema to link the schema to specific providers and a database name.Recorder. Define the provider and data_schema. In the run() method, fetch data (e.g., via an API) and use df_to_db to persist it.Mixin and register them with register_schema.record_data() and query_data().# 1. Define entity Schema
from sqlalchemy import Column, String, Float
from sqlalchemy.orm import declarative_base
from zvt.contract.schema import TradableEntity
from zvt.contract.register import register_schema, register_entity
CountryMetaBase = declarative_base()
@register_entity(entity_type="country")
class Country(CountryMetaBase, TradableEntity):
__tablename__ = "country"
region = Column(String(length=128))
capital_city = Column(String(length=128))
income_level = Column(String(length=64))
lending_type = Column(String(length=64))
longitude = Column(Float)
latitude = Column(Float)
register_schema(providers=["wb"], db_name="country_meta", schema_base=CountryMetaBase)
# 2. Implement recorder
from zvt.contract.api import df_to_db
from zvt.contract.recorder import Recorder
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)