text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|> action: ActionLiteral,
quantity: float,
current_price: float,
portfolio: Portfolio,
) -> int:
if quantity is None or quantity <= 0:
return 0
# Coerce to enum if strings provided
try:
action_enum = Action(action) if not isinsta... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>essive calculation over time.
"""
sharpe_ratio: Optional[float]
sortino_ratio: Optional[float]
max_drawdown: Optional[float]
max_drawdown_date: Optional[str]
long_short_ratio: Optional[float]
gross_exposure: Optional[float]
net_exposure: Optional[float]
<|fim_prefix|>fro... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>"Compute portfolio summary fields in a pure, testable function.
Returns a dict with keys matching the arguments used by format_backtest_row
for the summary row (excluding is_summary and date-specific fields).
"""
cash_balance = portfolio.get_cash()
total_position_value = total_value -... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>ysts": getattr(args, "analysts", None),
})
model_name, model_provider = select_model(getattr(args, "ollama", False), getattr(args, "model", None))
start_date, end_date = resolve_dates(getattr(args, "start_date", None), getattr(args, "end_date", None), default_months_back=default_months_back)
... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>class Cache:
"""In-memory cache for API responses."""
def __init__(self):
self._prices_cache: dict[str, list[dict[str, any]]] = {}
self._financial_metrics_cache: dict[str, list[dict[str, any]]] = {}
self._line_items_cache: dict[str, list[dict[str, any]]] = {}
self.... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>from pydantic import BaseModel
class Price(BaseModel):
open: float
close: float
high: float
low: float
volume: int
time: str
class PriceResponse(BaseModel):
ticker: str
prices: list[Price]
class FinancialMetrics(BaseModel):
ticker: str
report_period: str
p... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|> return [convert_to_serializable(item) for item in obj]
elif isinstance(obj, dict):
return {key: convert_to_serializable(value) for key, value in obj.items()}
else:
return str(obj) # Fallback to string representation
if isinstance(output, (dict, list)):... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|> """Enum for supported LLM providers"""
ALIBABA = "Alibaba"
ANTHROPIC = "Anthropic"
DEEPSEEK = "DeepSeek"
GOOGLE = "Google"
GROQ = "Groq"
KIMI = "Kimi"
META = "Meta"
MISTRAL = "Mistral"
OPENAI = "OpenAI"
OLLAMA = "Ollama"
OPENROUTER = "OpenRouter"
GIGACHAT... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>d selected analyst nodes
for analyst_key in selected_analysts:
node_name, node_func = analyst_nodes[analyst_key]
workflow.add_node(node_name, node_func)
workflow.add_edge("start_node", node_name)
# Always add risk and portfolio management
workflow.add_node("risk_manage... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>open", "close", "high", "low", "volume"]
for col in numeric_cols:
df[col] = pd.to_numeric(df[col], errors="coerce")
df.sort_index(inplace=True)
return df
# Update the get_price_data function to use the new functions
def get_price_data(ticker: str, start_date: str, end_date: str, api_... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>e application."""
<|fim_prefix|># This file can b<|fim_middle|>e empty
"""Utility modules for th<|endoftext|> | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>"""Constants and utilities related to analysts configuration."""
from src.agents import portfolio_manager
from src.agents.aswath_damodaran import aswath_damodaran_agent
from src.agents.ben_graham import ben_graham_agent
from src.agents.bill_ackman import bill_ackman_agent
from src.agents.cathie_wood impo... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>eys') and request.api_keys:
return request.api_keys.get(api_key_name)
return None<|fim_prefix|>
<|fim_middle|>
def get_api_key_from_state(state: dict, api_key_name: str) -> str:
"""Get an API key from the state object."""
if state and state.get("metadata", {}).get("request"):
... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>from colorama import Fore, Style
from tabulate import tabulate
from .analysts import ANALYST_ORDER
import os
import json
def sort_agent_signals(signals):
"""Sort agent signals in a consistent order."""
# Create order mapping from ANALYST_ORDER
analyst_order = {display: idx for idx, (display,... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>
# Print a status message every minute
if total_wait_time % 60 == 0:
minutes = total_wait_time // 60
print(f"{Fore.CYAN}Download in progress... ({minutes} minute{'s' if minutes != 1 else ''} elapsed){Style.RESET_ALL}")
# If we get here, we've timed out
... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>"""Helper functions for LLM"""
import json
from pydantic import BaseModel
from src.llm.models import get_model, get_model_info
from src.utils.progress import progress
from src.graph.state import AgentState
def call_llm(
prompt: any,
pydantic_model: type[BaseModel],
agent_name: str | None = ... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|> try:
install_process = subprocess.run(["bash", "-c", "curl -fsSL https://ollama.com/install.sh | sh"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
if install_process.returncode == 0:
print(f"{Fore.GREEN}Ollama in... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>from datetime import datetime, timezone
from rich.console import Console
from rich.live import Live
from rich.table import Table
from rich.style import Style
from <|fim_suffix|>[[str, Optional[str], str], None]):
"""Register a handler to be called when agent status updates."""
self.update_... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|> "graph.png"
with open(file_path, "wb") as f:
f.write(png_image)<|fim_prefix|>from langgraph.graph.state import CompiledGraph
from langchain_core.runnables.graph import MermaidDrawMethod
def save_graph_as_png(app: CompiledGraph, output_file_path) -> None:
png_image = app.get_graph().draw... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>#<|fim_suffix|>ge <|fim_middle|> Tests packa<|endoftext|> | fim | virattt/ai-hedge-fund | python |
import pytest
from src.backtesting.portfolio import Portfolio
@pytest.fixture()
def portfolio() -> Portfolio:
return Portfolio(tickers=["AAPL", "MSFT"], initial_cash=100_000.0, margin_requirement=0.5)
@pytest.fixture()
def prices() -> dict[str, float]:
return {"AAPL": 100.0, "MSFT": 200.0}
@pytest.fixtur... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>et_prices", lambda *a, **k: None)
def _fake_get_financial_metrics(ticker: str, end_date: str, period: str = "ttm", limit: int = 10, api_key: str | None = None):
return _load_financial_metrics_from_fixture(ticker, end_date, limit)
monkeypatch.setattr("src.backtesting.engine.get_financial_me... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>from src.backtesting.types import AgentOutput
class MockConfigurableAgent:
"""Mock agent that executes a predefined sequence of trading decisions."""
def __init__(self, decision_sequence: list[dict], tickers: list[str]):
"""
Args:
decision_sequence: List of decis... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>gains["MSFT"]["long"] != 0.0, "MSFT should have realized gains/losses from multiple cycles"
assert realized_gains["TSLA"]["long"] == 0.0, "TSLA should have no realized gains (not traded)"
# Cost basis should be reset to zero for AAPL and MSFT after final full exit
assert positions["AAPL"]... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>from src.backtesting.engine import BacktestEngine
from tests.backtesting.integration.mocks import MockConfigurableAgent
def test_long_short_strategy_partial_exits():
"""Simultaneous long and short with partial exits on both sides."""
tickers = ["AAPL", "MSFT", "TSLA"]
start_date = "2024-03-... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>from src.backtesting.engine import BacktestEngine
from tests.backtesting.integration.mocks import MockConfigurableAgent
def test_short_only_strategy_shorts_and_covers():
"""Short, hold, then partial cover. Validate positions, realized gains, and summary consistency."""
tickers = ["AAPL", "MSFT"... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>from src.backtesting.controller import AgentController
def dummy_agent(**kwargs):
# Echo basic structure with only one decision
tickers = kwargs["tickers"]
return {
"decisions": {tickers[0]: {"action": "buy", "quantity": "10"}},
"analyst_signals": {"agentA": {tickers[0]: {"si... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>from src.backtesting.trader import TradeExecutor
def test_trade_executor_routes_actions(portfolio):
ex = TradeExecutor()
# buy
qty = ex.execute_trade("AAPL", "buy", 10, 100.0, portfolio)
assert qty == 10
# sell
qty = ex.execute_trade("AAPL", "sell", 5, 100.0, portfolio)
asse... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>}
calc.update_metrics(metrics, vals)
assert metrics["sharpe_ratio"] is not None
assert metrics["sortino_ratio"] is not None
assert metrics["max_drawdown"] < 0.0
assert isinstance(metrics.get("max_drawdown_date"), str)
def test_metrics_zero_volatility_sharpe_zero():
calc = Perform... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>l_when_insufficient_margin_cash() -> None:
# Small cash: only enough margin for 4 shares at 50% of proceeds
p = Portfolio(tickers=["AAPL"], initial_cash=200.0, margin_requirement=0.5)
# price=100 → margin per share = 50, cash 200 → max 4 shares
executed = p.apply_short_open("AAPL", 10, 100... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>from src.backtesting.output import OutputBuilder
def test_results_builder_builds_rows_and_summary(monkeypatch, portfolio):
rows_captured = []
def fake_format_backtest_row(**kwargs):
# Keep a compact tuple to validate ordering and key fields
rows_captured.append((
kwa... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|> )
assert summary["cash_balance"] == 99_000.0
assert summary["total_position_value"] == 1_000.0
assert summary["total_value"] == total_value
assert summary["return_pct"] == 0.0
assert summary["sharpe_ratio"] == 1.0
<|fim_prefix|>from src.backtesting.valuation import calculate_portfoli... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>import os
import pytest
from unittest.mock import Mock, patch, call
from src.tools.api import _make_api_request, get_prices
class TestRateLimiting:
"""Test suite for API rate limiting functionality."""
@patch('src.tools.api.time.sleep')
@patch('src.tools.api.requests.get')
def test_hand... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>"a"}
assert result[1] == {"id": 2, "value": "b"}
def test_does_not_mutate_existing_list(self):
cache = Cache()
existing = [{"id": 1}]
original_len = len(existing)
cache._merge_data(existing, [{"id": 2}], key_field="id")
assert len(existing) == original_... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>ll, name: str) -> str | None:
for keyword in call.keywords:
if keyword.arg == name and isinstance(keyword.value, ast.Constant):
return keyword.value.value
return None
def test_shared_cli_accepts_documented_ticker_alias() -> None:
ticker_calls = [
call
for ... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>
feature engineering, portfolio construction, risk management,
and execution simulation.
"""
<|fim_prefix|>"""AI Hedge Fund v2<|fim_middle|> — quantitative trading stack.
A clean-room rebuild focused on quant fundamentals:
data pipelines, event studies, backtesting, validation,<|endoftext|> | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>
<|fim_prefix|>"""v2 backtesting — pluggable strategies and simulation engine."""
from v2.backtesting.engine import BacktestEngine
from v2.backtesti<|fim_middle|>ng.models import (
BacktestResult,
PerformanceMetrics,
Trade,
TradeSignal,
)
from v2.backtesting.strategy import PEADStrategy, ... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>
# Industrials (10)
"CAT", "DE", "HON", "UPS", "RTX", "BA", "LMT", "GE", "MMM", "UNP",
# Media / Telecom (7)
"DIS", "CMCSA", "T", "VZ", "TMUS", "CHTR", "WBD",
# Other (10)
"V", "MA", "PYPL", "NEE", "D", "SO", "DUK", "ABNB", "COIN", "NOW",
]
HOLDING_DAYS = 5
CAPITAL = 100_000.0
PER... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>"""Generic backtesting engine.
Simulates trade execution from strategy-generated signals.
Handles position sizing, price lookup, equity curve, and metrics.
The engine is strategy-agnostic — it only sees TradeSignals.
Usage:
from v2.data import FDClient
from v2.backtesting import BacktestEngine, ... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>"""Pydantic models for backtesting results."""
from __future__ import annotations
from typing import Any
from pydantic import BaseModel, Field
class TradeSignal(BaseModel):
"""A strategy's instruction to enter a position.
The strategy decides ticker, direction, timing, and holding period.
... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>"""Base class for backtesting strategies and the PEAD implementation.
A strategy's single job: given tickers and a data client, produce a list
of TradeSignals. The engine handles everything else (position sizing,
price lookup, equity curve, metrics).
To create a new strategy:
1. Subclass Strategy
... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>"""Tests for the backtesting engine."""
from __future__ import annotations
import os
import pytest
from v2.backtesting.models import TradeSignal
from v2.backtesting.engine import BacktestEngine
from v2.backtesting.strategy import PEADStrategy
from v2.data.models import EarningsData, EarningsRecord, Pr... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>d_dotenv()
<|fim_prefix|>"""Load .env for v2 tests so FINANCIAL_DATASETS<|fim_middle|>_API_KEY is available."""
from dotenv import load_dotenv
loa<|endoftext|> | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>"""v2 data pipeline — data provider protocol, FD client, and response models."""
from v2.data.client import FDClient
from v2.data.models i<|fim_suffix|>ncialMetrics,
InsiderTrade,
Price,
)
from v2.data.protocol import DataClient
__all__ = [
"CompanyFacts",
"CompanyNews",
"DataClient"... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>"""Financial Datasets API client."""
from __future__ import annotations
import logging
import os
import time
import requests
from v2.data.models import (
CompanyFacts,
CompanyNews,
Earnings,
EarningsRecord,
FinancialMetrics,
InsiderTrade,
Price,
)
logger = logging.getLogge... | fim | virattt/ai-hedge-fund | python |
"""Pydantic models for Financial Datasets API responses.
Field names and nullability match the FD backend serializers.
All models use ``extra="ignore"`` for forward-compatibility.
"""
from __future__ import annotations
from pydantic import BaseModel
_IGNORE = {"extra": "ignore"}
# -------------------------------... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>"""Data provider protocol — the interface all data sources implement.
Any class with these methods can be used as a data provider throughout
the v2 pipeline. No inheritance required — Python's structural typing
handles the rest.
Example::
class YFinanceClient:
def get_prices(self, ticker, s... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|> earnings = fd.get_earnings(ticker)
assert earnings is not None, f"No earnings for {ticker}"
print(f" {ticker} earnings: report={earnings.report_period} fiscal={earnings.fiscal_period}")
if earnings.quarterly:
q = earnings.quarterly
print(f" Q: rev={q.revenue} EPS={q.ear... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|> "plot_car_by_source",
"plot_car_distribution",
"plot_cumulative_ar",
]
<|fim_prefix|>"""v2 event study framework.
CARs around earnings, market model for expected returns,
cross-sectional t-tests and bootstrap confidence intervals.
"""
from v2.event_study.engine import compute_car
from v2.eve... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>"""Run the event study engine. Screen-record friendly output.
Usage: poetry run python -m v2.event_study
"""
from __future__ import annotations
import sys
import time
from v2.data import FDClient
from v2.event_study import compute_car
TICKERS = [
# Tech (21)
"AAPL", "MSFT", "AMZN", "GOOGL", ... | fim | virattt/ai-hedge-fund | python |
"""Event study engine — compute CARs around earnings announcements.
This is the main orchestration module. The pipeline:
1. Fetch SPY prices once (market benchmark for all tickers).
2. For each ticker:
a. Get earnings history from FD API.
b. Filter out retrospective rows (45-day rule).
c.... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>ped due to missing data.
"""
events: list[EventCAR] = Field(default_factory=list)
aggregates: list[AggregateResult] = Field(default_factory=list)
skipped_tickers: list[str] = Field(default_factory=list)
<|fim_prefix|>"""Pydantic models for event study results.
These models capture every ... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>"""Matplotlib visualizations for event study results.
Three chart types:
plot_car_by_source — grouped bar chart comparing mean CARs across
source types and windows (the "headline" chart)
plot_car_distribution — histograms showing the spread of individual CARs
p... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>e.
3. Repeat 10,000 times → distribution of possible means.
4. Take the 2.5th and 97.5th percentiles → 95% CI.
If the CI doesn't include 0, the mean CAR is statistically significant
(non-parametric analog of the t-test — doesn't assume normality).
rng_seed makes results reproducible ... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>n}"
source_types_seen = {e.source_type for e in result.events}
assert len(source_types_seen) >= 1
<|fim_prefix|>"""Tests for the event study engine."""
from __future__ import annotations
import os
import numpy as np
import pytest
from v2.event_study.models import EventCAR, EventStudyResult, Ma... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>"""v2 feature engineering.
Earnings surprise<|fim_suffix|>lead-lag, feature importance (MDA/MDI/SFI).
"""
<|fim_middle|> features, KPI momentum,
cross-sector <|endoftext|> | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>buy", "sell", "short", "cover"]
shares: int = 0
price: float = 0.0
estimated_cost: float = 0.0
reason: str = ""
class ExecutionResult(BaseModel):
"""Output of the execution layer."""
orders: list[TradeOrder] = Field(default_factory=list)
total_cost: float = 0.0
<|fim_prefix|... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>execution)."""
<|fim_prefix|>"""v2 pipeline — end-to-end o<|fim_middle|>rchestration (data through <|endoftext|> | fim | virattt/ai-hedge-fund | python |
"""v2 execution simulation.
Focus: Almgren-Chriss optimal execution, fill probability,
market impact modeling, Sharpe degradation at scale.
"""
<|endoftext|> | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>"""v2 portfolio constructio<|fim_suffix|>."""
<|fim_middle|>n — optimization and target weights<|endoftext|> | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>Pastur),
Black-Litterman, risk parity.
"""
<|fim_prefix|>"""v2 portfolio optimizer.
Focus: mean-variance optimization, eigenvalue cleaning<|fim_middle|> (Marchenko-<|endoftext|> | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|><|fim_prefix|>"""v2 risk <|fim_middle|>management — limits, sizing, and monitoring."""
<|endoftext|> | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>"""<|fim_suffix|> drawdown controls, position sizing by volatility,
correlation-based exposure caps, tail risk metrics, stress testing.
"""
<|fim_middle|>v2 risk management.
Focus:<|endoftext|> | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>egister here as they are implemented.
See v2/signals/base.py for the BaseSignal ABC.
"""
from __future__ import annotations
from v2.signals.base import BaseSignal
SIGNAL_REGISTRY: dict[str, type[BaseSignal]] = {}
<|fim_prefix|>"""Quantita<|fim_middle|>tive signal registry.
Concrete signals r<|endoftex... | fim | virattt/ai-hedge-fund | python |
<|fim_prefix|>"""Base class for all v2 quantitative signals."""
from __future__ import annotations
from abc import ABC, abstractmethod
import numpy as np
import pandas as pd
from v2.models import SignalResult
class BaseSignal(ABC):
"""Abstract base for Layer 1 quantitative signals.
Each signal fetches da... | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>n (CPCV),
Probability of Backtest Overfitting (PBO).
"""
<|fim_prefix|>"""v2 validat<|fim_middle|>ion framework.
Combinatorial Purged Cross-Validatio<|endoftext|> | fim | virattt/ai-hedge-fund | python |
<|fim_suffix|>))
}
<|fim_prefix|>import path from 'node:path'
import { writeFileSync } from 'node:fs'
import { Feed } from 'feed'
import type { SiteConfig } from 'vitepress'
import { createContentLoader } from 'vitepress'
const siteUrl = 'https://vite.dev'
const blogUrl = `${siteUrl}/blog`
export const buildEnd = asy... | fim | vitejs/vite | typescript |
<|fim_suffix|>hanges/ssr-using-modulerunner',
},
{
text: 'Shared Plugins During Build',
link: '/changes/shared-plugins-during-build',
},
],
},
{
text: 'Past',
items: [],
},
],
},
outline:... | fim | vitejs/vite | typescript |
<|fim_prefix|>interface Window {
__VITE_B<|fim_suffix|>ng
}
<|fim_middle|>ANNER_ID__: stri<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>;(() => {
const restore = (key, cls, def = false) => {
const saved = localStorage.getItem(key)
if (saved ? sa<|fim_suffix|>TE_BANNER_ID__}`, 'banner-dismissed')
})()
<|fim_middle|>ved !== 'false' : def) {
document.documentElement.classList.add(cls)
}
}
window.__VITE_BANNER_ID__ = ... | fim | vitejs/vite | javascript |
import { onMounted, ref } from 'vue'
import type { Sponsor, SponsorTier } from '@voidzero-dev/vitepress-theme'
interface Sponsors {
main: Sponsor[]
partnership: Sponsor[]
platinum: Sponsor[]
gold: Sponsor[]
}
// shared data across instances so we load only once.
const data = ref<SponsorTier[]>()
export funct... | fim | vitejs/vite | typescript |
<|fim_suffix|>t ScrimbaLink from './components/ScrimbaLink.vue'
export default {
Layout() {
return h((Theme as any).Layout, null, {
'aside-ads-before': () => h(AsideSponsors),
})
},
enhanceApp(ctx: any) {
const { app } = ctx
app.component('SvgImage', SvgImage)
app.component('YouTubeVid... | fim | vitejs/vite | typescript |
import { type Ref, onBeforeUnmount, onMounted, ref } from 'vue'
type YoutubeState = 'play' | 'pause' | 'end' | 'buffer' | 'unstarted' | 'cued'
interface YoutubePlayerState {
state: YoutubeState
}
const STATE_BY_CODE: Record<number, YoutubeState> = {
[-1]: 'unstarted',
[0]: 'end',
[1]: 'play',
[2]: 'pause',... | fim | vitejs/vite | typescript |
<|fim_suffix|> } catch {
// Package might not exist in node_modules (optional peer dep, etc.)
return null
}
}
function groupByAuthor(dependencies: Dependency[]): Author[] {
const authorMap = new Map<
string,
{ url?: string; packages: AuthorPackage[] }
>()
for (const dep of dependencies) {
... | fim | vitejs/vite | typescript |
<|fim_suffix|>.md', {
// excerpt: true,
transform(raw): Post[] {
return raw
.map(({ url, frontmatter }) => ({
title: frontmatter.head.find(
(e: any) => e[1].property === 'og:title',
)[1].content,
url,
date: formatDate(frontmatter.date),
}))
.sort((a, b... | fim | vitejs/vite | typescript |
<|fim_prefix|>export const core = [
{
avatar: 'https://www.github.com/yyx990803.png',
name: 'Evan You',
title: 'Creator',
org: 'Vue.js',
orgLink: 'https://vuejs.org/',
desc: 'Independent open source developer, creator of Vue.js and Vite.',
links: [
{ icon: 'github', link: 'https://gi... | fim | vitejs/vite | javascript |
<|fim_prefix|>// @ts-check
import eslint from '@eslint/js'
import pluginN from 'eslint-plugin-n'
import pluginImportX from 'eslint-plugin-import-x'
import pluginRegExp from 'eslint-plugin-regexp'
import tseslint from 'typescript-eslint'
import { defineConfig } from 'eslint/config'
import globals from 'globals'
// Some... | fim | vitejs/vite | javascript |
<|fim_suffix|>wd: import.meta.dirname,
})
expect(stdout).toContain(
`Target directory "subfolder/${projectName}" is not empty.`,
)
})
test('asks to overwrite non-empty current directory', () => {
createNonEmptyDir()
const { stdout } = run(['.', '--interactive'], { cwd: genPath })
expect(stdout).toConta... | fim | vitejs/vite | typescript |
#!/usr/bin/env node
import './dist/index.js'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import { fileURLToPath } from 'node:url'
import util from 'node:util'
import type { SpawnOptions } from 'node:child_process'
import spawn from 'cross-spawn'
import mri from 'mri'
import * as prompts from '@clack/prompts'
import { determineAgent } from ... | fim | vitejs/vite | typescript |
<|fim_suffix|> line-height: 135%;
display: inline-flex;
padding: 4px 8px;
border-radius: 4px;
color: var(--text-h);
background: var(--code-bg);
}
.counter {
font-family: var(--mono);
font-size: 16px;
display: inline-flex;
padding: 5p... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { LitElement, css, html } from 'lit'
import { customElement, property } from 'lit/decorators.js'
import litLogo from './assets/lit.svg'
import viteLogo from './assets/vite.svg'
import heroImg from './assets/hero.png'
/**
* An example element.
*
* @slot - This element has a slot
* @csspart butt... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { useState } from 'preact/hooks'
import preactLogo from './assets/preact.svg'
import viteLogo from './assets/vite.svg'
import heroImg from './assets/hero.png'
import './app.css'
export function App() {
const [count, setCount] = useState(0)
return (
<>
<section id="center">
<... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { ren<|fim_suffix|>tById('app'))
<|fim_middle|>der } from 'preact'
import './index.css'
import { App } from './app.jsx'
render(<App />, document.getElemen<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>i<|fim_suffix|>ite.dev/config/
export default defineConfig({
plugins: [preact()],
})
<|fim_middle|>mport { defineConfig } from 'vite'
import preact from '@preact/preset-vite'
// https://v<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { useState } from 'preact/hooks'
import preactLogo from './assets/preact.svg'
import viteLogo from './assets/vite.svg'
import heroImg from './assets/hero.png'
import './app.css'
export function App() {
const [count, setCount] = useState(0)
return (
<>
<section id="center">
<... | fim | vitejs/vite | typescript |
import { render } from 'preact'
import './index.css'
import { App } from './app.tsx'
render(<App />, document.getElementById('app')!)
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import { defineConfig } from 'vite'
im<|fim_suffix|>fig/
export default defineConfig({
plugins: [preact()],
})
<|fim_middle|>port preact from '@preact/preset-vite'
// https://vite.dev/con<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|> </li>
<li>
<a href="https://x.com/vite_js" target="_blank">
<svg class="button-icon" role="presentation" aria-hidden="true">
<use href="/icons.svg#x-icon"></use>
</svg>
X.com
</a>
</... | fim | vitejs/vite | javascript |
<|fim_prefix|>import '@builder.io/qwik/qwikloader.js'
import { render } from '@builder.io/<|fim_suffix|>p.jsx'
render(document.getElementById('app'), <App />)
<|fim_middle|>qwik'
import './index.css'
import { App } from './ap<|endoftext|> | fim | vitejs/vite | javascript |
import { defineConfig } from 'vite'
import { qwikVite } from '@builder.io/qwik/optimizer'
// https://vite.dev/config/
export default defineConfig({
plugins: [
qwikVite({
csr: true,
}),
],
})
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>>
<div id="social">
<svg class="icon" role="presentation" aria-hidden="true">
<use href="/icons.svg#social-icon"></use>
</svg>
<h2>Connect with us</h2>
<p>Join the Vite community</p>
<ul>
<li>
<a href="https://... | fim | vitejs/vite | typescript |
<|fim_suffix|>dex.css'
import { App } from './app.tsx'
render(document.getElementById('app') as HTMLElement, <App />)
<|fim_prefix|>import '@builder.io/qwik/qwikloader.js'
import { render }<|fim_middle|> from '@builder.io/qwik'
import './in<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>{ qwikVite } from '@builder.io/qwik/optimizer'
// https://vite.dev/config/
export default defineConfig({
plugins: [
qwikVite({
csr: true,
}),
],
})
<|fim_prefix|>import { <|fim_middle|>defineConfig } from 'vite'
import <|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import js from '@eslint/js'
import globals from 'globals'
import reactHo<|fim_suffix|>alIgnores } from 'eslint/config'
export default defineConfig([
globalIgnores(['dist']),
{
files: ['**/*.{js,jsx}'],
extends: [
js.configs.recommended,
reactHooks.configs.flat.recommended,
r... | fim | vitejs/vite | javascript |
<|fim_suffix|> >
<use href="/icons.svg#bluesky-icon"></use>
</svg>
Bluesky
</a>
</li>
</ul>
</div>
</section>
<div className="ticks"></div>
<section id="spacer"></section>
</>
)
}
export de... | fim | vitejs/vite | javascript |
<|fim_suffix|>jsx'
createRoot(document.getElementById('root')).render(
<StrictMode>
<App />
</StrictMode>,
)
<|fim_prefix|>import { StrictMode } from 'react'
import { createRoot } from 'react-dom/client'
import './index.css'
import App<|fim_middle|> from './App.<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>neConfig } from 'vite'
import react from '@vitejs/plugin-react'
// https://vite.dev/config/
export default defineConfig({
plugins: [react()],
})
<|fim_prefix|>import <|fim_middle|>{ defi<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import js from '@eslint/js'
import globals from 'globals'
import reactHooks from 'eslint-plugin-react-hooks'
import reactRefresh from 'eslint-plugin-react-refresh'
import tseslint from 'typescript-eslint'
import { defineConfig, globalIgnores } from 'eslint/config'
export default defineConfig([
globalIg... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { useState } from 'react'
import reactLogo from './assets/react.svg'
import viteLogo from './assets/vite.svg'
import heroImg from './assets/hero.png'
import './App.css'
function App() {
const [count, setCount] = useState(0)
return (
<>
<section id="center">
<div className="h... | fim | vitejs/vite | typescript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.