Market Data Collection¶

from api.tasks.market_metrics import (
    MarketMetricsCollector,
    collect_and_store_btc_dominance,
    collect_and_store_total_market_cap,
    collect_and_store_fear_greed_index,
)

# Initialize collector
collector = MarketMetricsCollector()

# Collect BTC dominance
btc_dom = collector.get_btc_dominance()
print(f"BTC Dominance: {btc_dom['value']}%")

# Collect total market cap
market_cap = collector.get_total_market_cap()
print(f"Total Market Cap: ${market_cap['value']:,.0f}")

# Collect Fear & Greed Index (last 7 days)
fear_greed = collector.get_fear_greed_index(limit=7)
for entry in fear_greed:
    print(f"{entry['timestamp']}: {entry['value']} - {entry['metadata']['value_classification']}")

# Analyze trend
trend = collector.analyze_fear_greed_trend(days=30)
print(f"Current: {trend['current_value']}, Trend: {trend['trend']}")

# Check for extremes
alert = collector.check_extreme_values()
if alert['is_extreme']:
    print(alert['message'])

# Store directly in database
collect_and_store_btc_dominance()
collect_and_store_total_market_cap()
collect_and_store_fear_greed_index(limit=30)

from api.orderbook import OrderBookCollector, OrderBookAnalyzer
from api.exchanges.binance_client import BinanceClient

# Initialize exchange client
client = BinanceClient(api_key='your_key', api_secret='your_secret')

# Initialize collector
collector = OrderBookCollector(client)

# Fetch and analyze order book
data = collector.fetch_and_analyze('BTCUSDT', limit=100)

# Access analysis results
print(f"Best Bid: {data['spread']['best_bid']}")
print(f"Best Ask: {data['spread']['best_ask']}")
print(f"Spread: {data['spread']['spread_percentage']:.4f}%")
print(f"Order Book Pressure: {data['imbalance']['pressure']}")
print(f"Support Levels: {data['support_resistance']['support'][:3]}")
print(f"Resistance Levels: {data['support_resistance']['resistance'][:3]}")

# Standalone analyzer
analyzer = OrderBookAnalyzer()
bids = [[50000, 1.5], [49999, 2.0], [49998, 1.8]]
asks = [[50001, 1.3], [50002, 2.2], [50003, 1.5]]

# Calculate support/resistance
sr = analyzer.calculate_support_resistance(bids, asks)
print(f"Support: {sr['support']}")
print(f"Resistance: {sr['resistance']}")

# Calculate imbalance
imbalance = analyzer.calculate_order_book_imbalance(bids, asks)
print(f"Imbalance: {imbalance['imbalance_percentage']:.2f}%")
print(f"Pressure: {imbalance['pressure']}")

# Calculate spread
spread = analyzer.calculate_spread_metrics(bids, asks)
print(f"Mid Price: {spread['mid_price']}")
print(f"Spread: {spread['spread_percentage']:.4f}%")

# In src/api/tasks/celery_tasks.py
from celery import shared_task
from api.tasks.market_metrics import (
    collect_and_store_btc_dominance,
    collect_and_store_total_market_cap,
    collect_and_store_fear_greed_index,
)

@shared_task
def collect_market_metrics_task():
    """Collect all market metrics."""
    collect_and_store_btc_dominance()
    collect_and_store_total_market_cap()
    collect_and_store_fear_greed_index(limit=1)

@shared_task
def collect_order_book_task(symbol='BTCUSDT'):
    """Collect order book snapshot."""
    from api.orderbook import collect_and_store_order_book
    from api.exchanges.binance_client import BinanceClient
    from dsta.config import Config

    config = Config()
    client = BinanceClient(
        api_key=config.get('BINANCE_API_KEY'),
        api_secret=config.get('BINANCE_API_SECRET')
    )

    collect_and_store_order_book(client, symbol)

from celery.schedules import crontab

CELERY_BEAT_SCHEDULE = {
    'collect-market-metrics-every-30-minutes': {
        'task': 'api.tasks.celery_tasks.collect_market_metrics_task',
        'schedule': crontab(minute='*/30'),
    },
    'collect-orderbook-every-5-seconds': {
        'task': 'api.tasks.celery_tasks.collect_order_book_task',
        'schedule': 5.0,  # seconds
        'args': ('BTCUSDT',)
    },
}

from api.models import MarketMetric
from datetime import datetime, timedelta

# Get recent metrics
now = datetime.now()
week_ago = now - timedelta(days=7)

btc_dom = MarketMetric.objects.filter(
    metric_type='btc_dominance',
    timestamp__gte=week_ago
).order_by('-timestamp').first()

fear_greed = MarketMetric.objects.filter(
    metric_type='fear_greed_index',
    timestamp__gte=week_ago
).order_by('-timestamp').first()

# Analyze conditions
if btc_dom and fear_greed:
    btc_value = float(btc_dom.value)
    fg_value = float(fear_greed.value)

    if fg_value < 25 and btc_value > 50:
        print("📊 Market Condition: EXTREME FEAR with BTC dominance rising")
        print("💡 Strategy: Consider accumulating quality altcoins")

    elif fg_value > 75 and btc_value < 40:
        print("📊 Market Condition: EXTREME GREED with low BTC dominance")
        print("💡 Strategy: Consider taking profits on altcoins")

from api.orderbook import OrderBookCollector
from api.exchanges.binance_client import BinanceClient

client = BinanceClient()
collector = OrderBookCollector(client)

# Analyze current order book
data = collector.fetch_and_analyze('BTCUSDT', limit=100)

imbalance = data['imbalance']
support = data['support_resistance']['support']
resistance = data['support_resistance']['resistance']

# Decision logic
if imbalance['pressure'] == 'buying' and imbalance['imbalance_percentage'] > 20:
    print("🟢 Strong buying pressure detected")
    print(f"   First support level: ${support[0]:,.2f}")
    print(f"   Suggested entry: Around ${support[0]:,.2f}")

elif imbalance['pressure'] == 'selling' and imbalance['imbalance_percentage'] < -20:
    print("🔴 Strong selling pressure detected")
    print(f"   First resistance level: ${resistance[0]:,.2f}")
    print(f"   Suggested exit: Around ${resistance[0]:,.2f}")

import logging
logger = logging.getLogger('api.tasks.market_metrics')
logger.setLevel(logging.INFO)

import logging
logging.basicConfig(level=logging.DEBUG)