kraken-data-collection-script

```python
import krakenex
import pandas as pd
from datetime import datetime
import time
import os
from typing import Dict, List, Optional
import logging
from huggingface_hub import HfApi

# Set up logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler(f'kraken_collection_{datetime.now().strftime("%Y%m%d")}.log'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

class KrakenHuggingFaceCollector:
    def __init__(self, kraken_key_path: str, repo_id: str):
        self.kraken_api = krakenex.API()
        try:
            self.kraken_api.load_key(kraken_key_path)
            logger.info("Successfully loaded Kraken API key")
        except Exception as e:
            logger.error(f"Failed to load Kraken API key: {e}")
            raise

        try:
            self.hf_api = HfApi()
            self.repo_id = repo_id
            logger.info("Successfully connected to Hugging Face")
        except Exception as e:
            logger.error(f"Failed to initialize Hugging Face API: {e}")
            raise
        
        self.pairs = [
            "XXBTZUSD",   # Bitcoin/USD
            "XETHZUSD",   # Ethereum/USD
            "XXRPZUSD",   # Ripple/USD
            "ADAUSD",     # Cardano/USD
            "XDGUSD",     # Dogecoin/USD
            "SOLUSD",     # Solana/USD
            "DOTUSD",     # Polkadot/USD
            "MATICUSD",   # Polygon/USD
            "LTCUSD"      # Litecoin/USD
        ]
        
        self.running = True
        self.data_points_collected = 0
        self.collection_start_time = None
        self.api_calls = 0
        self.last_api_reset = datetime.now()

    def check_api_rate(self) -> bool:
        """Monitor API call rate"""
        current_time = datetime.now()
        if (current_time - self.last_api_reset).total_seconds() >= 30:
            self.api_calls = 0
            self.last_api_reset = current_time
        return self.api_calls < 15

    def fetch_ticker_data(self, pair: str) -> Optional[Dict]:
        """Fetch ticker data with rate limiting"""
        if not self.check_api_rate():
            logger.warning("API rate limit approaching, waiting...")
            time.sleep(2)
            
        try:
            self.api_calls += 1
            response = self.kraken_api.query_public('Ticker', {'pair': pair})
            
            if 'error' in response and response['error']:
                logger.error(f"Kraken API error for {pair}: {response['error']}")
                return None
                
            data = response['result']
            pair_data = list(data.values())[0]
            
            return {
                'timestamp': datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f'),
                'pair': pair,
                'price': float(pair_data['c'][0]),
                'volume': float(pair_data['v'][0]),
                'bid': float(pair_data['b'][0]),
                'ask': float(pair_data['a'][0]),
                'low': float(pair_data['l'][0]),
                'high': float(pair_data['h'][0]),
                'vwap': float(pair_data['p'][0]),
                'trades': int(pair_data['t'][0])
            }
            
        except Exception as e:
            logger.error(f"Error fetching data for {pair}: {e}")
            return None

    def upload_to_huggingface(self, df: pd.DataFrame, timestamp: str) -> None:
        """Upload DataFrame to Hugging Face as CSV"""
        try:
            # Create local directories
            os.makedirs('data/continuous', exist_ok=True)
            
            # Save locally first
            local_path = f'data/continuous/kraken_trades_{timestamp}.csv'
            df.to_csv(local_path, index=False)
            
            # Upload to Hugging Face
            self.hf_api.upload_file(
                path_or_fileobj=local_path,
                path_in_repo=f"data/continuous/kraken_trades_{timestamp}.csv",
                repo_id=self.repo_id,
                repo_type="dataset"
            )
            
            logger.info(f"Successfully uploaded batch to Hugging Face")
            
        except Exception as e:
            logger.error(f"Error uploading to Hugging Face: {e}")
            logger.info(f"Data saved locally at: {local_path}")

    def collect_continuous(self, interval_minutes: int = 3, batch_size: int = 30):
        """
        Enhanced continuous data collection
        
        Args:
            interval_minutes: Minutes between each collection (default: 3)
            batch_size: Number of snapshots per batch (default: 30)
        """
        self.collection_start_time = datetime.now()
        logger.info(f"Starting enhanced continuous collection at {self.collection_start_time}")
        logger.info(f"Collecting {batch_size} snapshots every {interval_minutes} minutes")
        logger.info(f"Total API calls per batch: ~{batch_size * len(self.pairs)}")
        logger.info(f"Estimated daily data points: {(24 * 60 // interval_minutes) * batch_size * len(self.pairs)}")
        logger.info("Press CTRL+C to stop collection")
        
        while self.running:
            try:
                batch_start_time = datetime.now()
                records = []
                
                for i in range(batch_size):
                    if not self.running:
                        break
                    
                    snapshot_start = datetime.now()
                    logger.info(f"Collecting snapshot {i+1}/{batch_size}")
                    
                    for pair in self.pairs:
                        if self.check_api_rate():
                            record = self.fetch_ticker_data(pair)
                            if record:
                                records.append(record)
                        else:
                            time.sleep(1)
                    
                    # Dynamic sleep calculation
                    elapsed = (datetime.now() - snapshot_start).total_seconds()
                    sleep_time = max(0.5, 1.5 - elapsed)
                    
                    if i < batch_size - 1 and self.running:
                        time.sleep(sleep_time)
                
                if records:
                    df = pd.DataFrame(records)
                    current_timestamp = datetime.now().strftime('%Y%m%d_%H%M')
                    self.upload_to_huggingface(df, current_timestamp)
                    
                    self.data_points_collected += len(records)
                    collection_duration = (datetime.now() - self.collection_start_time)
                    
                    logger.info("\nBatch Summary:")
                    logger.info(f"Records in batch: {len(records)}")
                    logger.info(f"Pairs collected: {len(df['pair'].unique())}")
                    logger.info(f"Total data points: {self.data_points_collected}")
                    logger.info(f"Collection duration: {collection_duration}")
                    logger.info(f"Data points per hour: {self.data_points_collected / collection_duration.total_seconds() * 3600:.2f}")
                
                # Adaptive interval timing
                batch_duration = (datetime.now() - batch_start_time).total_seconds()
                sleep_time = max(0, interval_minutes * 60 - batch_duration)
                
                if self.running and sleep_time > 0:
                    logger.info(f"Waiting {sleep_time:.2f} seconds until next batch...")
                    time.sleep(sleep_time)
                
            except Exception as e:
                logger.error(f"Error in continuous collection: {e}")
                logger.info("Waiting 30 seconds before retry...")
                time.sleep(30)
                
        logger.info("Data collection stopped")
        logger.info(f"Total data points collected: {self.data_points_collected}")
        logger.info(f"Total collection time: {datetime.now() - self.collection_start_time}")

def main():
    try:
        collector = KrakenHuggingFaceCollector(
            kraken_key_path="kraken.key",
            repo_id="GotThatData/kraken-trading-data"
        )
        
        # Start collection with enhanced parameters
        collector.collect_continuous(
            interval_minutes=3,  # Collect every 3 minutes
            batch_size=30       # 30 snapshots per batch
        )
        
    except KeyboardInterrupt:
        logger.info("Stopping collection (CTRL+C pressed)")
        collector.running = False
    except Exception as e:
        logger.error(f"Fatal error: {e}")
        raise

if __name__ == "__main__":
    main()
```

To use this script:

1. Save it as `kraken_data_collector.py`

2. Make sure you have your `kraken.key` file with your API credentials

3. Install required packages if you haven't:
```bash
pip install krakenex pandas huggingface_hub
```

4. Run the script:
```bash
python kraken_data_collector.py
```

This will:
- Collect 30 snapshots every 3 minutes
- Save data locally and to Hugging Face
- Provide detailed logging
- Handle errors gracefully
- Respect API rate limits