chris/myTradeTracker
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial release v1.1.0

Browse Source 
- Complete MVP for tracking Fidelity brokerage account performance
- Transaction import from CSV with deduplication
- Automatic FIFO position tracking with options support
- Real-time P&L calculations with market data caching
- Dashboard with timeframe filtering (30/90/180 days, 1 year, YTD, all time)
- Docker-based deployment with PostgreSQL backend
- React/TypeScript frontend with TailwindCSS
- FastAPI backend with SQLAlchemy ORM

Features:
- Multi-account support
- Import via CSV upload or filesystem
- Open and closed position tracking
- Balance history charting
- Performance analytics and metrics
- Top trades analysis
- Responsive UI design

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
This commit is contained in:
Chris
2026-01-22 14:27:43 -05:00
commit eea4469095
90 changed files with 14513 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

273
backend/app/api/endpoints/analytics_v2.py Normal file
View File

@@ -0,0 +1,273 @@
"""
Enhanced analytics API endpoints with efficient market data handling.
This version uses PerformanceCalculatorV2 with:
- Database-backed price caching
- Rate-limited API calls
- Stale-while-revalidate pattern for better UX
"""
from fastapi import APIRouter, Depends, Query, BackgroundTasks
from sqlalchemy.orm import Session
from typing import Optional
from datetime import date
from app.api.deps import get_db
from app.services.performance_calculator_v2 import PerformanceCalculatorV2
from app.services.market_data_service import MarketDataService
router = APIRouter()
@router.get("/overview/{account_id}")
def get_overview(
account_id: int,
refresh_prices: bool = Query(default=False, description="Force fresh price fetch"),
max_api_calls: int = Query(default=5, ge=0, le=50, description="Max Yahoo Finance API calls"),
start_date: Optional[date] = None,
end_date: Optional[date] = None,
db: Session = Depends(get_db)
):
"""
Get overview statistics for an account.
By default, uses cached prices (stale-while-revalidate pattern).
Set refresh_prices=true to force fresh data (may be slow).
Args:
account_id: Account ID
refresh_prices: Whether to fetch fresh prices from Yahoo Finance
max_api_calls: Maximum number of API calls to make
start_date: Filter positions opened on or after this date
end_date: Filter positions opened on or before this date
db: Database session
Returns:
Dictionary with performance metrics and cache stats
"""
calculator = PerformanceCalculatorV2(db, cache_ttl=300)
# If not refreshing, use cached only (fast)
if not refresh_prices:
max_api_calls = 0
stats = calculator.calculate_account_stats(
account_id,
update_prices=True,
max_api_calls=max_api_calls,
start_date=start_date,
end_date=end_date
)
return stats
@router.get("/balance-history/{account_id}")
def get_balance_history(
account_id: int,
days: int = Query(default=30, ge=1, le=3650),
db: Session = Depends(get_db),
):
"""
Get account balance history for charting.
This endpoint doesn't need market data, so it's always fast.
Args:
account_id: Account ID
days: Number of days to retrieve (default: 30)
db: Database session
Returns:
List of {date, balance} dictionaries
"""
calculator = PerformanceCalculatorV2(db)
history = calculator.get_balance_history(account_id, days)
return {"data": history}
@router.get("/top-trades/{account_id}")
def get_top_trades(
account_id: int,
limit: int = Query(default=10, ge=1, le=100),
start_date: Optional[date] = None,
end_date: Optional[date] = None,
db: Session = Depends(get_db),
):
"""
Get top performing trades.
This endpoint only uses closed positions, so no market data needed.
Args:
account_id: Account ID
limit: Maximum number of trades to return (default: 10)
start_date: Filter positions closed on or after this date
end_date: Filter positions closed on or before this date
db: Database session
Returns:
List of trade dictionaries
"""
calculator = PerformanceCalculatorV2(db)
trades = calculator.get_top_trades(account_id, limit, start_date, end_date)
return {"data": trades}
@router.get("/worst-trades/{account_id}")
def get_worst_trades(
account_id: int,
limit: int = Query(default=10, ge=1, le=100),
start_date: Optional[date] = None,
end_date: Optional[date] = None,
db: Session = Depends(get_db),
):
"""
Get worst performing trades.
This endpoint only uses closed positions, so no market data needed.
Args:
account_id: Account ID
limit: Maximum number of trades to return (default: 10)
start_date: Filter positions closed on or after this date
end_date: Filter positions closed on or before this date
db: Database session
Returns:
List of trade dictionaries
"""
calculator = PerformanceCalculatorV2(db)
trades = calculator.get_worst_trades(account_id, limit, start_date, end_date)
return {"data": trades}
@router.post("/refresh-prices/{account_id}")
def refresh_prices(
account_id: int,
max_api_calls: int = Query(default=10, ge=1, le=50),
db: Session = Depends(get_db),
):
"""
Manually trigger a price refresh for open positions.
This is useful when you want fresh data but don't want to wait
on the dashboard load.
Args:
account_id: Account ID
max_api_calls: Maximum number of Yahoo Finance API calls
db: Database session
Returns:
Update statistics
"""
calculator = PerformanceCalculatorV2(db, cache_ttl=300)
stats = calculator.update_open_positions_pnl(
account_id,
max_api_calls=max_api_calls,
allow_stale=False # Force fresh fetches
)
return {
"message": "Price refresh completed",
"stats": stats
}
@router.post("/refresh-prices-background/{account_id}")
def refresh_prices_background(
account_id: int,
background_tasks: BackgroundTasks,
max_api_calls: int = Query(default=20, ge=1, le=50),
db: Session = Depends(get_db),
):
"""
Trigger a background price refresh.
This returns immediately while prices are fetched in the background.
Client can poll /overview endpoint to see updated data.
Args:
account_id: Account ID
background_tasks: FastAPI background tasks
max_api_calls: Maximum number of Yahoo Finance API calls
db: Database session
Returns:
Acknowledgment that background task was started
"""
def refresh_task():
calculator = PerformanceCalculatorV2(db, cache_ttl=300)
calculator.update_open_positions_pnl(
account_id,
max_api_calls=max_api_calls,
allow_stale=False
)
background_tasks.add_task(refresh_task)
return {
"message": "Price refresh started in background",
"account_id": account_id,
"max_api_calls": max_api_calls
}
@router.post("/refresh-stale-cache")
def refresh_stale_cache(
min_age_minutes: int = Query(default=10, ge=1, le=1440),
limit: int = Query(default=20, ge=1, le=100),
db: Session = Depends(get_db),
):
"""
Background maintenance endpoint to refresh stale cached prices.
This can be called periodically (e.g., via cron) to keep cache fresh.
Args:
min_age_minutes: Only refresh prices older than this many minutes
limit: Maximum number of prices to refresh
db: Database session
Returns:
Number of prices refreshed
"""
market_data = MarketDataService(db, cache_ttl_seconds=300)
refreshed = market_data.refresh_stale_prices(
min_age_seconds=min_age_minutes * 60,
limit=limit
)
return {
"message": "Stale price refresh completed",
"refreshed": refreshed,
"min_age_minutes": min_age_minutes
}
@router.delete("/clear-old-cache")
def clear_old_cache(
older_than_days: int = Query(default=30, ge=1, le=365),
db: Session = Depends(get_db),
):
"""
Clear old cached prices from database.
Args:
older_than_days: Delete prices older than this many days
db: Database session
Returns:
Number of records deleted
"""
market_data = MarketDataService(db)
deleted = market_data.clear_cache(older_than_days=older_than_days)
return {
"message": "Old cache cleared",
"deleted": deleted,
"older_than_days": older_than_days
}