Update kraken-data-collection-script

kraken-data-collection-script

@@ -5,6 +5,8 @@ import time
 import os
 from typing import Dict, List, Optional
 import logging
+from huggingface_hub import HfApi, login
+from io import StringIO
 
 # Set up logging
 logging.basicConfig(
@@ -17,16 +19,27 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-class KrakenDataCollector:
-    """Handles data collection from Kraken API"""
+class KrakenHuggingFaceCollector:
+    """Handles data collection from Kraken and uploading to Hugging Face"""
     
-    def __init__(self, api_key_path: str):
-        self.api = krakenex.API()
+    def __init__(self, kraken_key_path: str, hf_token: str, repo_id: str):
+        # Initialize Kraken API
+        self.kraken_api = krakenex.API()
         try:
-            self.api.load_key(api_key_path)
+            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 API key: {e}")
+            logger.error(f"Failed to load Kraken API key: {e}")
+            raise
+
+        # Initialize Hugging Face
+        try:
+            login(token=hf_token)
+            self.hf_api = HfApi()
+            self.repo_id = repo_id
+            logger.info("Successfully logged in to Hugging Face")
+        except Exception as e:
+            logger.error(f"Failed to login to Hugging Face: {e}")
             raise
         
         # Trading pairs to collect data for
@@ -46,7 +59,7 @@ class KrakenDataCollector:
     def fetch_ticker_data(self, pair: str) -> Optional[Dict]:
         """Fetch ticker data for a single pair"""
         try:
-            response = self.api.query_public('Ticker', {'pair': pair})
+            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']}")
@@ -72,17 +85,31 @@ class KrakenDataCollector:
             logger.error(f"Error fetching data for {pair}: {e}")
             return None
 
-    def create_data_directories(self) -> None:
-        """Create directory structure for data storage"""
-        for split in ['training', 'validation', 'test']:
-            directory = f'data/{split}'
-            if not os.path.exists(directory):
-                os.makedirs(directory)
-                logger.info(f"Created directory: {directory}")
+    def upload_to_huggingface(self, df: pd.DataFrame, split: str) -> None:
+        """Upload DataFrame to Hugging Face as CSV"""
+        try:
+            # Convert DataFrame to CSV string
+            csv_str = df.to_csv(index=False)
+            
+            # Upload to Hugging Face
+            path_in_repo = f"data/{split}/kraken_trades.csv"
+            
+            self.hf_api.upload_file(
+                path_or_fileobj=StringIO(csv_str),
+                path_in_repo=path_in_repo,
+                repo_id=self.repo_id,
+                repo_type="dataset"
+            )
+            
+            logger.info(f"Successfully uploaded {split} data to Hugging Face")
+            
+        except Exception as e:
+            logger.error(f"Error uploading to Hugging Face: {e}")
+            raise
 
-    def save_data_to_csv(self, split: str, num_rows: int, delay: int = 2) -> None:
+    def collect_and_upload(self, split: str, num_rows: int, delay: int = 2) -> None:
         """
-        Collect and save data for all pairs
+        Collect data and upload directly to Hugging Face
         
         Args:
             split: Data split type ('training', 'validation', 'test')
@@ -103,16 +130,11 @@ class KrakenDataCollector:
                 if i < num_rows - 1:  # Don't sleep after last iteration
                     time.sleep(delay)  # Respect API rate limits
             
-            # Create DataFrame and save to CSV
+            # Create DataFrame
             df = pd.DataFrame(records)
-            file_path = f"data/{split}/kraken_trades.csv"
-            
-            # Create directory if it doesn't exist
-            os.makedirs(os.path.dirname(file_path), exist_ok=True)
             
-            # Save data
-            df.to_csv(file_path, index=False)
-            logger.info(f"Successfully saved {len(records)} records to {file_path}")
+            # Upload to Hugging Face
+            self.upload_to_huggingface(df, split)
             
             # Print data summary
             logger.info("\nData Summary:")
@@ -121,19 +143,20 @@ class KrakenDataCollector:
             logger.info(f"Time range: {df['timestamp'].min()} to {df['timestamp'].max()}")
             
         except Exception as e:
-            logger.error(f"Error saving data: {e}")
+            logger.error(f"Error in data collection and upload: {e}")
             raise
 
 def main():
-    """Main function to run data collection"""
+    """Main function to run data collection and upload"""
     try:
         # Initialize collector
-        collector = KrakenDataCollector("kraken.key")
-        
-        # Create directory structure
-        collector.create_data_directories()
+        collector = KrakenHuggingFaceCollector(
+            kraken_key_path="kraken.key",
+            hf_token="your_huggingface_token",  # Replace with your token
+            repo_id="GotThatData/kraken-trading-data"  # Replace with your repo name
+        )
         
-        # Collect data for each split
+        # Collect and upload data for each split
         splits_config = {
             'training': 1000,    # 1000 rows for training
             'validation': 200,   # 200 rows for validation
@@ -141,13 +164,13 @@ def main():
         }
         
         for split, num_rows in splits_config.items():
-            logger.info(f"\nCollecting {split} data...")
-            collector.save_data_to_csv(split=split, num_rows=num_rows)
+            logger.info(f"\nCollecting and uploading {split} data...")
+            collector.collect_and_upload(split=split, num_rows=num_rows)
             
-        logger.info("Data collection completed successfully!")
+        logger.info("Data collection and upload completed successfully!")
         
     except Exception as e:
-        logger.error(f"Fatal error in data collection: {e}")
+        logger.error(f"Fatal error: {e}")
         raise
 
 if __name__ == "__main__":