Historical forex data in Python: sample, coverage, API, and audit paths

EURUSD_M1.parquet    # 1-minute bars
EURUSD_M5.parquet    # 5-minute bars
EURUSD_M15.parquet   # 15-minute bars
EURUSD_H1.parquet    # 1-hour bars
EURUSD_H4.parquet    # 4-hour bars
EURUSD_D1.parquet    # Daily bars
EURUSD_W1.parquet    # Weekly bars

npm run data:loader-benchmark

# Outputs:
# data/loader-benchmark-report.json
# docs/LOADER_BENCHMARK_REPORT.md

import pandas as pd

# Load a single pair
df = pd.read_parquet('EURUSD_M1.parquet')

# View the data
print(df.head())
print(f"Rows: {len(df):,}")
print(f"Date range: {df['timestamp'].min()} to {df['timestamp'].max()}")

from pathlib import Path

# Load all major pairs
majors = ['EURUSD', 'GBPUSD', 'USDJPY', 'USDCHF', 'AUDUSD', 'USDCAD', 'NZDUSD', 'EURGBP']
data = {}

for pair in majors:
    data[pair] = pd.read_parquet(f'{pair}_H1.parquet')

# Access individual pair
eurusd = data['EURUSD']

df = pd.read_parquet('EURUSD_H1.parquet')
df = df.set_index('timestamp')

# Now you can slice by date
df_2023 = df['2023']
df_q1 = df['2023-01':'2023-03']

# Load M1 data and resample to H4
df = pd.read_parquet('EURUSD_M1.parquet')
df = df.set_index('timestamp')

df_h4 = df.resample('4H').agg({
    'open': 'first',
    'high': 'max',
    'low': 'min',
    'close': 'last',
    'volume': 'sum'
}).dropna()

# Install arrow package (first time only)
install.packages("arrow")

library(arrow)

# Load data
df <- read_parquet("EURUSD_H1.parquet")

# View structure
str(df)
head(df)

# Convert timestamp to POSIXct
df$timestamp <- as.POSIXct(df$timestamp, origin = "1970-01-01", tz = "UTC")

library(arrow)
library(dplyr)
library(lubridate)

df <- read_parquet("EURUSD_D1.parquet") %>%
  mutate(
    timestamp = as_datetime(timestamp),
    year = year(timestamp),
    returns = (close - lag(close)) / lag(close)
  )

# Annual summary
df %>%
  group_by(year) %>%
  summarize(
    total_return = prod(1 + returns, na.rm = TRUE) - 1,
    volatility = sd(returns, na.rm = TRUE) * sqrt(252)
  )

import pandas as pd

# Convert to CSV
df = pd.read_parquet('EURUSD_D1.parquet')
df.to_csv('EURUSD_D1.csv', index=False)

# Or filter first to reduce size
df_2023 = df[df['timestamp'].dt.year == 2023]
df_2023.to_csv('EURUSD_D1_2023.csv', index=False)

import pandas as pd
import numpy as np

df = pd.read_parquet('EURUSD_H1.parquet')
df = df.set_index('timestamp')

# Calculate moving averages
df['sma_20'] = df['close'].rolling(20).mean()
df['sma_50'] = df['close'].rolling(50).mean()

# Generate signals
df['signal'] = np.where(df['sma_20'] > df['sma_50'], 1, -1)
df['signal'] = df['signal'].shift(1)  # Avoid lookahead bias

# Calculate returns
df['returns'] = df['close'].pct_change()
df['strategy_returns'] = df['signal'] * df['returns']

# Performance
total_return = (1 + df['strategy_returns']).prod() - 1
print(f"Strategy Return: {total_return:.2%}")

from backtesting import Backtest, Strategy
from backtesting.lib import crossover
import pandas as pd

class SmaCross(Strategy):
    n1 = 20
    n2 = 50

    def init(self):
        self.sma1 = self.I(lambda x: pd.Series(x).rolling(self.n1).mean(), self.data.Close)
        self.sma2 = self.I(lambda x: pd.Series(x).rolling(self.n2).mean(), self.data.Close)

    def next(self):
        if crossover(self.sma1, self.sma2):
            self.buy()
        elif crossover(self.sma2, self.sma1):
            self.sell()

# Load data
df = pd.read_parquet('EURUSD_H1.parquet')
df = df.set_index('timestamp')
df.columns = ['Open', 'High', 'Low', 'Close', 'Volume']

bt = Backtest(df, SmaCross, cash=10000, commission=.0002)
stats = bt.run()
print(stats)

import pandas as pd
import numpy as np

pairs = ['EURUSD', 'GBPUSD', 'USDJPY', 'AUDUSD']
results = {}

for pair in pairs:
    df = pd.read_parquet(f'{pair}_D1.parquet')
    df = df.set_index('timestamp')

    # Calculate daily returns
    df['returns'] = df['close'].pct_change()

    results[pair] = {
        'mean_return': df['returns'].mean() * 252,  # Annualized
        'volatility': df['returns'].std() * np.sqrt(252),
        'sharpe': (df['returns'].mean() / df['returns'].std()) * np.sqrt(252)
    }

pd.DataFrame(results).T