Market Data

class PricingInfo:
    """Get current pricing."""
    def __init__(self, accountID: str, params: dict = None): ...
    # params: instruments (required, comma-separated), since, includeUnitsAvailable, includeHomeConversions

class PricingStream:
    """Stream real-time pricing."""
    def __init__(self, accountID: str, params: dict = None): ...
    # params: instruments (required, comma-separated), snapshot

    def terminate(self, message: str = ""): ...

from oandapyV20.endpoints.pricing import PricingInfo, PricingStream

# Get current prices
prices = api.request(PricingInfo(
    accountID=account_id,
    params={"instruments": "EUR_USD,GBP_USD"}
))['prices']

for price in prices:
    bid = price['bids'][0]['price']
    ask = price['asks'][0]['price']
    print(f"{price['instrument']}: Bid={bid}, Ask={ask}, Spread={float(ask)-float(bid):.5f}")

# Stream prices
stream = PricingStream(accountID=account_id, params={"instruments": "EUR_USD"})
for update in api.request(stream):
    if update['type'] == 'PRICE':
        print(f"Bid: {update['bids'][0]['price']}, Ask: {update['asks'][0]['price']}")
    elif update['type'] == 'HEARTBEAT':
        print(f"Heartbeat: {update['time']}")

class InstrumentsCandles:
    """Get candlestick (OHLC) data."""
    def __init__(self, instrument: str, params: dict = None): ...
    # params: price (M|B|A|BA), granularity, count (max 5000), from, to, smooth, includeFirst

class InstrumentsOrderBook:
    """Get order book snapshot."""
    def __init__(self, instrument: str, params: dict = None): ...
    # params: time

class InstrumentsPositionBook:
    """Get position book snapshot."""
    def __init__(self, instrument: str, params: dict = None): ...
    # params: time

from oandapyV20.endpoints.instruments import InstrumentsCandles

# Recent candles
candles = api.request(InstrumentsCandles(
    instrument="EUR_USD",
    params={"granularity": "H1", "count": 100}
))['candles']

for candle in candles:
    if candle['complete']:
        mid = candle['mid']
        print(f"{candle['time']}: O={mid['o']}, H={mid['h']}, L={mid['l']}, C={mid['c']}, V={candle['volume']}")

# Date range
from datetime import datetime, timedelta
to_time = datetime.utcnow()
from_time = to_time - timedelta(days=30)

candles = api.request(InstrumentsCandles(
    instrument="EUR_USD",
    params={
        "granularity": "D",
        "from": from_time.strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
        "to": to_time.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
    }
))['candles']

# Bid/Ask prices
candles = api.request(InstrumentsCandles(
    instrument="EUR_USD",
    params={"granularity": "M5", "count": 50, "price": "BA"}
))['candles']

from oandapyV20.contrib.factories import InstrumentsCandlesFactory

# Automatically handles pagination for >5000 candles
params = {
    "from": "2023-01-01T00:00:00Z",
    "to": "2023-12-31T23:59:59Z",
    "granularity": "H1"
}

all_candles = []
for endpoint in InstrumentsCandlesFactory("EUR_USD", params):
    response = api.request(endpoint)
    all_candles.extend(response['candles'])
    print(f"Retrieved {len(response['candles'])} candles, total: {len(all_candles)}")

from oandapyV20.endpoints.instruments import InstrumentsOrderBook, InstrumentsPositionBook

# Order book
orderbook = api.request(InstrumentsOrderBook(instrument="EUR_USD"))['orderBook']
print(f"Price: {orderbook['price']}")
for bucket in orderbook['buckets']:
    print(f"{bucket['price']}: Long={bucket['longCountPercent']}%, Short={bucket['shortCountPercent']}%")

# Position book
positionbook = api.request(InstrumentsPositionBook(instrument="EUR_USD"))['positionBook']

class Calendar:
    """Economic calendar."""
    def __init__(self, params: dict): ...
    # params: instrument, period (seconds)

class HistoricalPositionRatios:
    """Trader positioning sentiment."""
    def __init__(self, params: dict): ...
    # params: instrument, period (seconds)

class Spreads:
    """Spread information."""
    def __init__(self, params: dict): ...
    # params: instrument, period (seconds)

class CommitmentsOfTraders:
    """COT data."""
    def __init__(self, params: dict): ...
    # params: instrument

class OrderbookData:
    """Orderbook data."""
    def __init__(self, params: dict): ...
    # params: instrument, period (seconds)

class Autochartist:
    """Technical analysis signals."""
    def __init__(self, params: dict = None): ...
    # params: instrument (optional), type (optional)

from oandapyV20.endpoints.forexlabs import (
    Calendar, HistoricalPositionRatios, Spreads, Autochartist
)

# Economic calendar
calendar = api.request(Calendar(params={"instrument": "EUR_USD", "period": "86400"}))

# Position ratios (sentiment)
ratios = api.request(HistoricalPositionRatios(
    params={"instrument": "EUR_USD", "period": "3600"}
))['data']
print(f"Long: {ratios['long_position_ratio']}%, Short: {ratios['short_position_ratio']}%")

# Spreads
spreads = api.request(Spreads(params={"instrument": "EUR_USD", "period": "86400"}))

# Technical signals
signals = api.request(Autochartist(params={"instrument": "EUR_USD"}))['signals']
for signal in signals:
    print(f"Pattern: {signal['pattern']}, Direction: {signal['direction']}, Quality: {signal['quality']}")

from oandapyV20.definitions.instruments import CandlestickGranularity

CandlestickGranularity.S5    # 5 seconds
CandlestickGranularity.S10   # 10 seconds
CandlestickGranularity.S15   # 15 seconds
CandlestickGranularity.S30   # 30 seconds
CandlestickGranularity.M1    # 1 minute
CandlestickGranularity.M2    # 2 minutes
CandlestickGranularity.M4    # 4 minutes
CandlestickGranularity.M5    # 5 minutes
CandlestickGranularity.M10   # 10 minutes
CandlestickGranularity.M15   # 15 minutes
CandlestickGranularity.M30   # 30 minutes
CandlestickGranularity.H1    # 1 hour
CandlestickGranularity.H2    # 2 hours
CandlestickGranularity.H3    # 3 hours
CandlestickGranularity.H4    # 4 hours
CandlestickGranularity.H6    # 6 hours
CandlestickGranularity.H8    # 8 hours
CandlestickGranularity.H12   # 12 hours
CandlestickGranularity.D     # 1 day
CandlestickGranularity.W     # 1 week
CandlestickGranularity.M     # 1 month

from oandapyV20.contrib.generic import granularity_to_time, secs2time

# Convert granularity to seconds
seconds = granularity_to_time("H1")  # 3600
seconds = granularity_to_time("D")   # 86400

# Convert epoch to datetime
dt = secs2time(1609459200)  # datetime(2021, 1, 1, 0, 0)