text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>hor,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'vnpy', 'vnpy Documentation',
author, 'vnpy', 'One line description of project.',
'Miscellaneous'),
]
# -- Options for intersphinx output ----------------------------------------------
intersphinx_mapping = {
... | fim | vnpy/vnpy | python |
from datetime import datetime
from vnpy.trader.ui import create_qapp, QtCore
from vnpy.trader.constant import Exchange, Interval
from vnpy.trader.database import get_database
from vnpy.chart import ChartWidget, VolumeItem, CandleItem
if __name__ == "__main__":
app = create_qapp()
database = get_database()
... | fim | vnpy/vnpy | python |
<|fim_suffix|>_ == "__main__":
main()
<|fim_prefix|>from vnpy.event import EventEngine
from vnpy.trader.engine import MainEngine
from vnpy.trader.ui import MainWindow, create_qapp
from vnpy_rpcservice import RpcGateway
from vnpy_ctastrategy import CtaStrategyApp
def main():
""""""
qapp = create_qapp()
... | fim | vnpy/vnpy | python |
from time import sleep
from vnpy.event import EventEngine, Event
from vnpy.trader.engine import MainEngine
from vnpy.trader.ui import MainWindow, create_qapp
from vnpy.trader.event import EVENT_LOG
from vnpy.trader.object import LogData
from vnpy_ctp import CtpGateway
from vnpy_rpcservice import RpcServiceApp
from vnp... | fim | vnpy/vnpy | python |
<|fim_prefix|>"""
该程序使用VeighNa框架通过CTP接口连接到期货市场，并自动录制指定交易所和品种的行情数据。
适合初学者了解VeighNa框架的基本用法和数据录制流程。
"""
# 加载Python标准库
from logging import INFO
from time import sleep
# 加载VeighNa核心框架
from vnpy.event import EventEngine, Event
from vnpy.trader.setting import SETTINGS
from vnpy.trader.engine import MainEngine, LogEngine
fr... | fim | vnpy/vnpy | python |
<|fim_suffix|>_engine.register(EVENT_CTA_LOG, log_engine.process_log_event)
logger.info("注册日志事件监听")
main_engine.connect(ctp_setting, "CTP")
logger.info("连接CTP接口")
sleep(10)
cta_engine.init_engine()
logger.info("CTA策略初始化完成")
cta_engine.init_all_strategies()
sleep(60) # Leave enough ... | fim | vnpy/vnpy | python |
<|fim_suffix|>address = "tcp://localhost:2014"
sub_address = "tcp://localhost:4102"
tc = TestClient()
tc.subscribe_topic("")
tc.start(req_address, sub_address)
while 1:
print(tc.add(1, 3))
sleep(2)
<|fim_prefix|>from time import sleep
from typing import Any
from vnpy.rpc import Rpc... | fim | vnpy/vnpy | python |
<|fim_prefix|>from time import sleep, time
from vnpy.rpc import RpcServer
class TestServer(RpcServer):
"""
Test RpcServer
"""
def __init__(self):
"""
Constructor
"""
super().__init__()
self.register(self.add)
def add(self, a, b):
"""
Test... | fim | vnpy/vnpy | python |
<|fim_prefix|>from time import sleep
from vnpy_scripttrader import ScriptEngine
def run(engine: ScriptEngine):
"""
脚本策略的主函数说明：
1. 唯一入参是<|fim_suffix|> # 轮询获取行情
for vt_symbol in vt_symbols:
tick = engine.get_tick(vt_symbol)
msg = f"最新行情, {tick}"
engine.wri... | fim | vnpy/vnpy | python |
<|fim_prefix|>from vnpy.event import EventEngine
from vnpy.trader.engine import MainEngine
from vnpy.trader.ui import MainWindow, create_qapp
from vnpy_ctp import CtpGateway
# from vnpy_ctptest import CtptestGateway
# from vnpy_mini import MiniGateway
# from vnpy_femas import FemasGateway
# from vnpy_sopt import Sopt... | fim | vnpy/vnpy | python |
<|fim_suffix|>arisons with scalars."""
df = make_test_df()
x = make_proxy(df, "x")
assert_int_data(x > 2, [0, 1, 0, 1])
assert_int_data(x >= 2, [0, 1, 1, 1])
assert_int_data(x < 3, [1, 0, 1, 0])
assert_int_data(x <= 3, [1, 1, 1, 0])
assert_int_data(x == 2, [0, 0, 1, 0])
assert_int_data(... | fim | vnpy/vnpy | python |
<|fim_prefix|>import pytest
import polars as pl
import numpy as np
from datetime import datetime, timedelta
from vnpy.alpha.dataset.utility import calculate_by_expression
def create_test_df(n_symbols: int = 50, n_days: int = 300) -> pl.DataFrame:
"""
Create test DataFrame with extreme values.
Columns: d... | fim | vnpy/vnpy | python |
<|fim_suffix|>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 ... | fim | vnpy/vnpy | python |
<|fim_prefix|>from .logger import logger
from .dataset import AlphaDataset, Segment, to_datetime, r<|fim_suffix|>port AlphaModel
from .strategy import AlphaStrategy, BacktestingEngine
from .lab import AlphaLab
__all__ = [
"logger",
"AlphaDataset",
"Segment",
"to_datetime",
"register_functions",
... | fim | vnpy/vnpy | python |
<|fim_prefix|>from .template import AlphaDataset
from .utility import Segment, to_datetime, register_functions
from .processor import (
process_drop_na,
process_fill_na,
process_cs_norm,
process_robust_zscore_norm,
process_cs_rank_norm,
process_replace_inf,
process_ts_norm,
process_drop_... | fim | vnpy/vnpy | python |
"""
Cross Section Operators
"""
import polars as pl
from .utility import DataProxy
def cs_rank(feature: DataProxy) -> DataProxy:
"""Perform cross-sectional ranking"""
df: pl.DataFrame = feature.df.select(
pl.col("datetime"),
pl.col("vt_symbol"),
pl.col("data").rank().over("datetime")... | fim | vnpy/vnpy | python |
<|fim_prefix|>import polars as pl
from vnpy.alpha import AlphaDataset
class Alpha101(AlphaDataset):
"""101 basic factors from WorldQuant"""
def __init__(
self,
df: pl.DataFrame,
train_period: tuple[str, str],
valid_period: tuple[str, str],
test_period: tuple[str, str]... | fim | vnpy/vnpy | python |
<|fim_suffix|>s_sum(ts_abs(volume - ts_delay(volume, 1)), {w}) + 1e-12)")
for w in windows:
self.add_feature(f"vsumd_{w}", f"(ts_sum(ts_greater(volume - ts_delay(volume, 1), 0), {w}) - ts_sum(ts_greater(ts_delay(volume, 1) - volume, 0), {w})) / (ts_sum(ts_abs(volume - ts_delay(volume, 1)), {w}) + 1... | fim | vnpy/vnpy | python |
<|fim_prefix|>"""
Math Functions
"""
import polars as pl
from .utility import DataProxy
def less(feature1: DataProxy, feature2: DataProxy | float) -> DataProxy:
"""Return the minimum value between two features"""
if isinstance(feature2, DataProxy):
df_merged: pl.DataFrame = feature1.df.join(feature2... | fim | vnpy/vnpy | python |
<|fim_prefix|>from datetime import datetime
import numpy as np
import polars as pl
from .utility import to_datetime
def process_drop_na(df: pl.DataFrame, names: list[str] | None = None) -> pl.DataFrame:
"""Remove rows with missing values"""
if names is None:
names = df.columns[2:-1]
for name in... | fim | vnpy/vnpy | python |
<|fim_suffix|>l
import pandas as pd
from .utility import DataProxy
def to_pd_series(feature: DataProxy) -> pd.Series:
"""Convert to pandas.Series data structure"""
series: pd.Series = feature.df.to_pandas().set_index(["datetime", "vt_symbol"])["data"]
return series
def to_pl_dataframe(series: pd.Series... | fim | vnpy/vnpy | python |
import time
from datetime import datetime
from typing import cast
from collections.abc import Callable
from multiprocessing import get_context
from multiprocessing.context import BaseContext
import polars as pl
import pandas as pd
from tqdm import tqdm
from alphalens.utils import get_clean_factor_and_forward_returns ... | fim | vnpy/vnpy | python |
<|fim_suffix|>rolling_map(lambda s: np.nanstd(s, ddof=0), window, min_samples=1).over("vt_symbol")
)
return DataProxy(df)
def ts_slope(feature: DataProxy, window: int) -> DataProxy:
"""Calculate the slope of linear regression over a rolling window (optimized)"""
# 预计算 x 相关的常数 (x = 0, 1, 2, ..., window... | fim | vnpy/vnpy | python |
<|fim_suffix|>] != other.df["data"]
else:
s = self.df["data"] != other
return self.result(self._comparison_series(s))
def calculate_by_expression(df: pl.DataFrame, expression: str) -> pl.DataFrame:
"""Execute calculation based on expression"""
# Import operators locally to avoid po... | fim | vnpy/vnpy | python |
<|fim_suffix|>d_parquet(file_path)
def remove_signal(self, name: str) -> bool:
"""Remove signal"""
file_path: Path = self.signal_path.joinpath(f"{name}.parquet")
if not file_path.exists():
logger.error(f"Signal file {name} does not exist")
return False
file_... | fim | vnpy/vnpy | python |
<|fim_prefix|>import sys
from loguru import logger
# Remove default output
logger.remove()
# Add terminal output
fm<|fim_suffix|>add(sys.stdout, colorize=True, format=fmt)
<|fim_middle|>t: str = "<green>{time:YYYY-MM-DD HH:mm:ss}</green> <level>{message}</level>"
logger.<|endoftext|> | fim | vnpy/vnpy | python |
<|fim_suffix|>el
__all__ = [
"AlphaModel",
]
<|fim_prefix|>from .templa<|fim_middle|>te import AlphaMod<|endoftext|> | fim | vnpy/vnpy | python |
<|fim_suffix|>.sort(["datetime", "vt_symbol"])
# Convert to numpy array
data: np.ndarray = df.select(df.columns[2: -1]).to_numpy()
# Return prediction results
result: np.ndarray = self.model.predict(data)
return result
def detail(self) -> None:
"""
Output ... | fim | vnpy/vnpy | python |
<|fim_prefix|>from typing import cast
import numpy as np
import polars as pl
import lightgbm as lgb
import matplotlib.pyplot as plt
from vnpy.alpha.dataset import AlphaDataset, Segment
from vnpy.alpha.model import AlphaModel
class LgbModel(AlphaModel):
"""LightGBM ensemble learning algorithm"""
def __init_... | fim | vnpy/vnpy | python |
<|fim_prefix|>import copy
from collections import defaultdict
from typing import Literal, cast
import numpy as np
import pandas as pd
import polars as pl
from sklearn.metrics import mean_squared_error # type: ignore
import torch
import torch.nn as nn
import torch.optim as optim
from vnpy.alpha import (
Alpha... | fim | vnpy/vnpy | python |
<|fim_prefix|>from abc import ABCMeta, abstractmethod
from typing import Any
import numpy as np
from vnpy.<|fim_suffix|>etail(self) -> Any:
"""
Output detailed information about the model
"""
return
<|fim_middle|>alpha.dataset import AlphaDataset, Segment
class AlphaModel(metaclass=A... | fim | vnpy/vnpy | python |
<|fim_suffix|>rategy",
"BacktestingEngine"
]
<|fim_prefix|>from .template import AlphaStrategy
from .backtesting import BacktestingEngine
__all__<|fim_middle|> = [
"AlphaSt<|endoftext|> | fim | vnpy/vnpy | python |
<|fim_prefix|>from collections import defaultdict
from datetime import date, datetime
from copy import copy
from typing import cast
import traceback
import numpy as np
import polars as pl
import plotly.graph_objects as go # type: ignore
from plotly.subplots import make_subplots # type: ignore
from ... | fim | vnpy/vnpy | python |
<|fim_prefix|>from collections import defaultdict
import polars as pl
from vnpy.trader.object import BarData, TradeData
from vnpy.trader.constant import Direction
from vnpy.trader.utility import round_to
from vnpy.alpha import AlphaStrategy
class EquityDemoStrategy(AlphaStrategy):
"""Equity Long-Only Demo Stra... | fim | vnpy/vnpy | python |
<|fim_suffix|>ice, volume)
def cover(self, vt_symbol: str, price: float, volume: float) -> list[str]:
"""Buy to close position"""
return self.send_order(vt_symbol, Direction.LONG, Offset.CLOSE, price, volume)
def send_order(
self,
vt_symbol: str,
direction: Direction,
... | fim | vnpy/vnpy | python |
<|fim_suffix|>olumeItem",
]
<|fim_prefix|>from .widget import ChartWidget
from .item import CandleItem, VolumeItem
__all__ = [
"Ch<|fim_middle|>artWidget",
"CandleItem",
"V<|endoftext|> | fim | vnpy/vnpy | python |
<|fim_suffix|>pg.AxisItem):
""""""
def __init__(self, manager: BarManager, *args: Any, **kwargs: Any) -> None:
""""""
super().__init__(*args, **kwargs)
self._manager: BarManager = manager
self.setPen(width=AXIS_WIDTH)
self.tickFont: QtGui.QFont = NORMAL_FONT
def t... | fim | vnpy/vnpy | python |
<|fim_prefix|>from vnpy.trader.ui import QtGui
W<|fim_suffix|> 0.8
NORMAL_FONT = QtGui.QFont("Arial", 9)
def to_int(value: float) -> int:
""""""
return int(round(value, 0))
<|fim_middle|>HITE_COLOR = (255, 255, 255)
BLACK_COLOR = (0, 0, 0)
GREY_COLOR = (100, 100, 100)
UP_COLOR = (255, 75, 75)
DOWN_COLOR = ... | fim | vnpy/vnpy | python |
from abc import abstractmethod
import pyqtgraph as pg # type: ignore
from vnpy.trader.ui import QtCore, QtGui, QtWidgets
from vnpy.trader.object import BarData
from .base import BLACK_COLOR, UP_COLOR, DOWN_COLOR, PEN_WIDTH, BAR_WIDTH
from .manager import BarManager
class ChartItem(pg.GraphicsObject):
""""... | fim | vnpy/vnpy | python |
<|fim_prefix|>from datetime import datetime
from _collections_abc import dict_keys
from vnpy.trader.object import BarData
from .base import to_int
class BarManager:
""""""
def __init__(self) -> None:
""""""
self._bars: dict[datetime, BarData] = {}
self._datetime_index_map: dict[date... | fim | vnpy/vnpy | python |
<|fim_prefix|>from datetime import datetime
import pyqtgraph as pg # type: ignore
from vnpy.trader.ui import QtGui, QtWidgets, QtCore
from vnpy.trader.object import BarData
from .manager import BarManager
from .base import (
GREY_COLOR, WHITE_COLOR, CURSOR_COLOR, BLACK_COLOR,
to_int, NORMAL_FONT
)
from ... | fim | vnpy/vnpy | python |
<|fim_suffix|>",
"EventEngine",
"EVENT_TIMER",
]
<|fim_prefix|>from .engine import Event, EventEngine, EVENT_TIMER
__all<|fim_middle|>__ = [
"Event<|endoftext|> | fim | vnpy/vnpy | python |
<|fim_suffix|>ler: HandlerType) -> None:
"""
Register a new handler function for a specific event type. Every
function can only be registered once for each event type.
"""
handler_list: list = self._handlers[type]
if handler not in handler_list:
handler_list.a... | fim | vnpy/vnpy | python |
<|fim_suffix|>pcServer",
]
<|fim_prefix|>from .client import RpcClient
from .server <|fim_middle|>import RpcServer
__all__ = [
"RpcClient",
"R<|endoftext|> | fim | vnpy/vnpy | python |
<|fim_suffix|>
return
# Stop RpcClient status
self._active = False
def join(self) -> None:
# Wait for RpcClient thread to exit
if self._thread and self._thread.is_alive():
self._thread.join()
self._thread = None
def run(self) -> None:
""... | fim | vnpy/vnpy | python |
<|fim_suffix|>0
HEARTBEAT_TOLERANCE = 30
<|fim_prefix|>import signal
<|fim_middle|># Achieve Ctrl-c interrupt recv
signal.signal(signal.SIGINT, signal.SIG_DFL)
HEARTBEAT_TOPIC = "heartbeat"
HEARTBEAT_INTERVAL = 1<|endoftext|> | fim | vnpy/vnpy | python |
<|fim_prefix|>import threading
import traceback
from time import time
from collections.abc import Callable
import zmq
from .common import HEARTBEAT_TOPIC, HEARTBEAT_INTERVAL
class RpcServer:
""""""
def __init__(self) -> None:
"""
Constructor
"""
# Save functions dict: key is... | fim | vnpy/vnpy | python |
from abc import ABC
from pathlib import Path
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from .engine import BaseEngine
class BaseApp(ABC):
"""
Abstract class for app.
"""
app_name: str # Unique name used for creating engine and widget
app_module: str ... | fim | vnpy/vnpy | python |
<|fim_suffix|> DAILY = "d"
WEEKLY = "w"
TICK = "tick"
<|fim_prefix|>"""
General constant enums used in the trading platform.
"""
from enum import Enum
from .locale import _
class Direction(Enum):
"""
Direction of order/trade/position.
"""
LONG = _("多")
SHORT = _("空")
NET = _("净")
... | fim | vnpy/vnpy | python |
<|fim_suffix|>eeds offset convert.
"""
contract: ContractData | None = self.get_contract(vt_symbol)
# Only contracts with long-short position mode requires convert
if not contract:
return False
elif contract.net_position:
return False
else:
... | fim | vnpy/vnpy | python |
<|fim_prefix|>from abc import ABC, abstractmethod
from datetime import datetime
from types import ModuleType
from dataclasses import dataclass
from importlib import import_module
from .constant import Interval, Exchange
from .object import BarData, TickData
from .setting import SETTINGS
from .utility import ZoneInfo
f... | fim | vnpy/vnpy | python |
<|fim_suffix|>tafeed
<|fim_prefix|>from types import ModuleType
from collections.abc import Callable
from importlib import import_module
from .object import HistoryRequest, TickData, BarData
from .setting import SETTINGS
from .locale import _
class BaseDatafeed:
"""
Abstract datafeed class for connecting to ... | fim | vnpy/vnpy | python |
<|fim_suffix|>bscribeRequest, gateway_name: str) -> None:
"""
Subscribe tick data update of a specific gateway.
"""
gateway: BaseGateway | None = self.get_gateway(gateway_name)
if gateway:
self.write_log(_("订阅行情 -> {}：{}").format(gateway_name, req))
gatew... | fim | vnpy/vnpy | python |
"""
Event type string used in the trading platform.
"""
from vnpy.event import EVENT_TIMER # noqa
EVENT_TICK = "eTick."
EVENT_TRADE = "eTrade."
EVENT_ORDER = "eOrder."
EVENT_POSITION = "ePosition."
EVENT_ACCOUNT = "eAccount."
EVENT_QUOTE = "eQuote."
EVENT_CONTRACT = "eContract."
EVENT_LOG = "eLog"
<|endoftext|> | fim | vnpy/vnpy | python |
from abc import ABC, abstractmethod
from vnpy.event import Event, EventEngine
from .event import (
EVENT_TICK,
EVENT_ORDER,
EVENT_TRADE,
EVENT_POSITION,
EVENT_ACCOUNT,
EVENT_CONTRACT,
EVENT_LOG,
EVENT_QUOTE,
)
from .object import (
TickData,
OrderData,
TradeData,
Positio... | fim | vnpy/vnpy | python |
import gettext
from pathlib import Path
localedir: Path = Path(__file__).parent
translations: gettext.GNUTranslations | gettext.NullTranslations = gettext.translation("vnpy", localedir=localedir, fallback=True)
_ = translations.gettext
<|endoftext|> | fim | vnpy/vnpy | python |
<|fim_suffix|> """Initialize the build hook"""
# Only generate mo file when building wheel
if "pure_python" not in build_data:
return
self.locale_path: Path = Path(self.root).joinpath("vnpy", "trader", "locale")
self.mo_path: Path = self.locale_path.joinpath("en", "LC_... | fim | vnpy/vnpy | python |
<|fim_suffix|>nk=file_path, level=level, format=format)
<|fim_prefix|>import sys
from datetime import datetime
from pathlib import Path
from logging import DEBUG, INFO, WARNING, ERROR, CRITICAL
from loguru import logger
from vnpy.trader.setting import SETTINGS
from vnpy.trader.utility import get_folder_path
__all__... | fim | vnpy/vnpy | python |
"""
Basic data structure used for general trading function in the trading platform.
"""
from dataclasses import dataclass, field
from datetime import datetime as Datetime
from .constant import Direction, Exchange, Interval, Offset, Status, Product, OptionType, OrderType
INFO: int = 20
ACTIVE_STATUSES = set([Statu... | fim | vnpy/vnpy | python |
<|fim_suffix|>sing Pool and Manager
ctx: BaseContext = get_context("spawn")
with ctx.Manager() as manager, ctx.Pool(max_workers) as pool:
# Create shared dict for result cache
cache: DictProxy[tuple, tuple] = manager.dict()
# Set up toolbox
toolbox: base.Toolbox = base.Toolbox()... | fim | vnpy/vnpy | python |
<|fim_prefix|>"""
Global setting of the trading platform.
"""
from logging import INFO
from tzlocal import get_localzone_name
from .utility import load_json
SETTINGS: dict = {
"font.family": "微软雅黑",
"font.size": 12,
"log.active": True,
"log.level": INFO,
"log.console": True,
"log.file": Tru... | fim | vnpy/vnpy | python |
<|fim_prefix|>fro<|fim_suffix|>",
"create_qapp",
]
<|fim_middle|>m .qt import QtCore, QtWidgets, QtGui, Qt, create_qapp
from .mainwindow import MainWindow
__all__ = [
"MainWindow",
"QtCore",
"QtWidgets",
"QtGui",
"Qt<|endoftext|> | fim | vnpy/vnpy | python |
<|fim_prefix|>"""
Implements main window of the trading platform.
"""
from types import ModuleType
import webbrowser
from functools import partial
from importlib import import_module
from typing import TypeVar, cast
from collections.abc import Callable
import vnpy
from vnpy.event import EventEngine
from .qt import Q... | fim | vnpy/vnpy | python |
<|fim_suffix|>
def _open_community(self) -> None:
""""""
webbrowser.open("https://www.vnpy.com/forum/forum/2-ti-wen-qiu-zhu")
<|fim_prefix|>import ctypes
import platform
import sys
import traceback
import webbrowser
import types
import threading
import qdarkstyle # type: ignore
from PySide6 import... | fim | vnpy/vnpy | python |
<|fim_suffix|>
alignment: int = QtCore.Qt.AlignmentFlag.AlignLeft
) -> QtWidgets.QLabel:
"""
Create label with certain font color.
"""
label: QtWidgets.QLabel = QtWidgets.QLabel()
if color:
label.setStyleSheet(f"color:{color}")
label.setAlignment(Q... | fim | vnpy/vnpy | python |
<|fim_prefix|>"""
General utility functions.
"""
import json
import sys
from datetime import datetime, time
from pathlib import Path
from collections.abc import Callable
from decimal import Decimal
from math import floor, ceil
from typing import overload, Literal
import numpy as np
import talib
from zoneinfo import Z... | fim | vnpy/vnpy | python |
<|fim_prefix|>"""
WeChat iLink protocol for sending text messages and polling updates.
"""
import base64
import json
import secrets
import time
import uuid
from dataclasses import dataclass
from typing import Any
import requests
from .locale import _
# Default WeChat iLink gateway URL
DEFAULT_BASE_URL: str = "http... | fim | vnpy/vnpy | python |
<|fim_suffix|>We only do `no-unused-vars` checks for js files, TS files are checked by TypeScript itself.
'no-unused-vars': ['error', { vars: 'all', args: 'none' }],
},
},
// Node scripts
{
files: [
'eslint.config.js',
'rollup*.config.js',
'scripts/**',
'./*.{js,ts}',
... | fim | vuejs/core | javascript |
<|fim_suffix|>FRAGMENT,
dynamicProps: undefined,
directives: undefined,
loc: locStub,
} as ForCodegenNode,
},
}),
)
expect(code).toMatch(`openBlock()`)
expect(code).toMatchSnapshot()
})
test('Element (callExpression + objectExpression + Templa... | fim | vuejs/core | typescript |
import { baseCompile as compile } from '../src'
import { type RawSourceMap, SourceMapConsumer } from 'source-map-js'
describe('compiler: integration tests', () => {
const source = `
<div id="foo" :class="bar.baz">
{{ world.burn() }}
<div v-if="ok">yes</div>
<template v-else>no</template>
<div v-for="(value, ... | fim | vuejs/core | typescript |
<|fim_prefix|>import { baseCompile } from '../src/compile'
/**
* Ensure all slot functions are wrapped with _withCtx
* which sets the currentRenderingInstance and curre<|fim_suffix|>ld>`, {
mode: 'module',
scopeId: 'test',
})
expect(code).toMatch(`default: _withCtx(() => [`)
expect(code).toMa... | fim | vuejs/core | typescript |
<|fim_suffix|>
},
}
}
type Flags = PatchFlags | ShapeFlags
export function genFlagText(
flag: Flags | Flags[],
names: { [k: number]: string } = PatchFlagNames,
): string {
if (isArray(flag)) {
let f = 0
flag.forEach(ff => {
f |= ff
})
return `${f} /* ${flag.map(f => names[f]).join(', ... | fim | vuejs/core | typescript |
<|fim_prefix|>import { baseParse } from '../src/parser'
import { type NodeTransform, transform } from '../src/transform'
import {
type DirectiveNode,
type ElementNode,
type ExpressionNode,
NodeTypes,
type VNodeCall,
} from '../src/ast'
import { ErrorCodes, createCompilerError } from '../src/errors'
import {
... | fim | vuejs/core | typescript |
<|fim_suffix|>oo }">{{ foo }}</Comp>`,
{
prefixIdentifiers: true,
},
)
expect(root.cached.length).toBe(0)
expect(generate(root).code).toMatchSnapshot()
})
test('should NOT cache elements with cached handlers', () => {
const root = transformWithCache(
`... | fim | vuejs/core | typescript |
<|fim_suffix|>no props or reactive data (so just the tag as the arg)
expect((node.codegenNode as VNodeCall).props).toBeUndefined()
})
})
<|fim_prefix|>import {
type ElementNode,
type VNodeCall,
noopDirectiveTransform,
baseParse as parse,
transform,
} from '../../src'
import { transformElement } from '..... | fim | vuejs/core | typescript |
<|fim_prefix|>import {
BindingTypes,
type CompilerOptions,
ErrorCodes,
type NodeTransform,
baseCompile,
baseParse as parse,
transform,
transformExpression,
} from '../../src'
import {
BASE_TRANSITION,
CREATE_VNODE,
GUARD_REACTIVE_PROPS,
KEEP_ALIVE,
MERGE_PROPS,
NORMALIZE_CLASS,
NORMALIZE_P... | fim | vuejs/core | typescript |
<|fim_suffix|> const { code } = compile(
`{{ (() => { switch (1) { case 1: const foo = "bar"; return \`\${foo}\`; } })() }}`,
)
expect(code).toMatch(`const foo = "bar";`)
expect(code).toMatch(`return \`\${foo}\`;`)
expect(code).not.toMatch(`_ctx.foo`)
})
test('should handl... | fim | vuejs/core | typescript |
<|fim_prefix|>import {
type CompilerOptions,
type ElementNode,
ErrorCodes,
NodeTypes,
baseParse as parse,
transform,
} from '../../src'
import { transformElement } from '../../src/transforms/transformElement'
import { transformOn } from '../../src/transforms/vOn'
import { transformBind } from '../../src/tra... | fim | vuejs/core | typescript |
import {
type CompilerOptions,
type ElementNode,
type ForNode,
NodeTypes,
generate,
isWhitespaceText,
baseParse as parse,
transform,
} from '../../src'
import { transformFor } from '../../src/transforms/vFor'
import { transformText } from '../../src/transforms/transformText'
import { transformExpression... | fim | vuejs/core | typescript |
<|fim_prefix|>import {
type CallExpression,
type CompilerOptions,
type ElementNode,
ErrorCodes,
NodeTypes,
type ObjectExpression,
type VNodeCall,
baseParse as parse,
transform,
} from '../../src'
import { transformBind } from '../../src/transforms/vBind'
import { transformElement } from '../../src/tra... | fim | vuejs/core | typescript |
<|fim_prefix|>import { baseParse as parse } from '../../src/parser'
import { transform } from '../../src/transform'
import { transformIf } from '../../src/transforms/vIf'
import { transformFor } from '../../src/transforms/vFor'
import { transformBind } from '../../src/transforms/vBind'
import { transformElement } from ... | fim | vuejs/core | typescript |
<|fim_suffix|>chSnapshot()
})
test('v-if on <slot/>', () => {
const {
root,
node: { codegenNode },
} = parseWithIfTransform(`<slot v-if="ok"></slot>`)
expect(codegenNode.consequent).toMatchObject({
type: NodeTypes.JS_CALL_EXPRESSION,
callee: RENDER_SLOT,
... | fim | vuejs/core | typescript |
<|fim_suffix|>hMemo([_ctx.updateKey]`)
expect(code).toContain(`{ key: _ctx.updateKey }`)
})
test('on normal element with dynamic key nested in v-for', () => {
const code = compile(
`<div v-for="item in items">
<div
v-memo="[item.id, updateKey]"
:key="get(item, updateKey)"
... | fim | vuejs/core | typescript |
<|fim_prefix|>import {
BindingTypes,
type CompilerOptions,
type ComponentNode,
type ElementNode,
type ForNode,
NORMALIZE_PROPS,
NodeTypes,
type ObjectExpression,
type PlainElementNode,
type VNodeCall,
generate,
baseParse as parse,
transform,
} from '../../src'
import { ErrorCodes } from '../..... | fim | vuejs/core | typescript |
<|fim_prefix|>import {
type CompilerOptions,
type ElementNode,
ErrorCodes,
NodeTypes,
type ObjectExpression,
TO_HANDLER_KEY,
type VNodeCall,
helperNameMap,
baseParse as parse,
transform,
} from '../../src'
import { transformFor } from '../../src/transforms/vFor'
import { transformOn } from '../../sr... | fim | vuejs/core | typescript |
<|fim_suffix|>ldren[0] as any).children[0].codegenNode).toMatchObject({
type: NodeTypes.JS_CACHE_EXPRESSION,
index: 0,
value: {
type: NodeTypes.JS_CALL_EXPRESSION,
callee: RENDER_SLOT,
},
})
expect(generate(root).code).toMatchSnapshot()
})
// v-once inside v-once sho... | fim | vuejs/core | typescript |
<|fim_prefix|>import {
type CompilerOptions,
type ComponentNode,
type ElementNode,
ErrorCodes,
type ForNode,
NodeTypes,
type ObjectExpression,
type RenderSlotCall,
type SimpleExpressionNode,
type SlotsExpression,
type VNodeCall,
generate,
baseParse as parse,
transform,
} from '../../src'
imp... | fim | vuejs/core | typescript |
<|fim_prefix|>import { babelParse, walkIdentifiers } from '@vue/compiler-sfc'
import {
type ExpressionNode,
type TransformContext,
isReferencedIdentifier,
} from '../src'
import { type Position, createSimpleExpression } from '../src/ast'
import {
advancePositionWithClone,
isMemberExpressionBrowser,
isMember... | fim | vuejs/core | typescript |
<|fim_prefix|>'use strict'
if (process.env.NO<|fim_suffix|>ist/compiler-core.cjs.js')
}
<|fim_middle|>DE_ENV === 'production') {
module.exports = require('./dist/compiler-core.cjs.prod.js')
} else {
module.exports = require('./d<|endoftext|> | fim | vuejs/core | javascript |
<|fim_suffix|>{
return {
type: NodeTypes.SIMPLE_EXPRESSION,
loc,
content,
isStatic,
constType: isStatic ? ConstantTypes.CAN_STRINGIFY : constType,
}
}
export function createInterpolation(
content: InterpolationNode['content'] | string,
loc: SourceLocation,
): InterpolationNode {
return {
... | fim | vuejs/core | typescript |
<|fim_prefix|>// should only use types from @babel/types
// do not import runtime methods
import type {
BlockStatement,
ForInStatement,
ForOfStatement,
ForStatement,
Function,
Identifier,
Node,
ObjectProperty,
Program,
SwitchCase,
SwitchStatement,
} from '@babel/types'
import { walk } from 'estree... | fim | vuejs/core | typescript |
<|fim_suffix|>st(node.arguments, context)
push(`)`)
}
function genObjectExpression(node: ObjectExpression, context: CodegenContext) {
const { push, indent, deindent, newline } = context
const { properties } = node
if (!properties.length) {
push(`{}`, NewlineType.None, node)
return
}
const multiline... | fim | vuejs/core | typescript |
<|fim_suffix|> return enabled
}
export function warnDeprecation(
key: CompilerDeprecationTypes,
context: MergedParserOptions | TransformContext,
loc: SourceLocation | null,
...args: any[]
): void {
const val = getCompatValue(key, context)
if (val === 'suppress-warning') {
return
}
const { message, ... | fim | vuejs/core | typescript |
<|fim_suffix|> rewriteFilter(prop.exp, context)
}
})
}
}
function rewriteFilter(node: ExpressionNode, context: TransformContext) {
if (node.type === NodeTypes.SIMPLE_EXPRESSION) {
parseFilter(node, context)
} else {
for (let i = 0; i < node.children.length; i++) {
const child = node... | fim | vuejs/core | typescript |
<|fim_suffix|> transformSlotOutlet,
transformElement,
trackSlotScopes,
transformText,
],
{
on: transformOn,
bind: transformBind,
model: transformModel,
},
]
}
// we name it `baseCompile` so that higher order compilers like
// @vue/compiler-dom can export `compile` whil... | fim | vuejs/core | typescript |
import type { SourceLocation } from './ast'
export interface CompilerError extends SyntaxError {
code: number | string
loc?: SourceLocation
}
export interface CoreCompilerError extends CompilerError {
code: ErrorCodes
}
export function defaultOnError(error: CompilerError): never {
throw error
}
export funct... | fim | vuejs/core | typescript |
<|fim_prefix|>export { baseCompile } from './compile'
// Also expose lower level APIs & types
export {
type CompilerOptions,
type ParserOptions,
type TransformOptions,
type CodegenOptions,
type HoistTransform,
type BindingMetadata,
BindingTypes,
} from './options'
export { baseParse } from './parser'
exp... | fim | vuejs/core | typescript |
<|fim_prefix|>import type {
ElementNode,
Namespace,
Namespaces,
ParentNode,
TemplateChildNode,
} from './ast'
import type { CompilerError } from './errors'
import type {
DirectiveTransform,
NodeTransform,
TransformContext,
} from './transform'
import type { CompilerCompatOptions } from './compat/compatC... | fim | vuejs/core | typescript |
<|fim_prefix|>import {
type AttributeNode,
ConstantTypes,
type DirectiveNode,
type ElementNode,
ElementTypes,
type ForParseResult,
Namespaces,
NodeTypes,
type RootNode,
type SimpleExpressionNode,
type SourceLocation,
type TemplateChildNode,
createRoot,
createSimpleExpression,
} from './ast'
... | fim | vuejs/core | typescript |
<|fim_prefix|>export const FRAGMENT: unique symbol = Symbol(__DEV__ ? `Fragment` : ``)
export const TELEPORT: unique symbol = Symbol(__DEV__ ? `Teleport` : ``)
export const SUSPENSE: unique symbol = Symbol(__DEV__ ? `Suspense` : ``)
export const KEEP_ALIVE: unique symbol = Symbol(__DEV__ ? `KeepAlive` : ``)
export cons... | fim | vuejs/core | typescript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.