Add daily updater script

scripts/daily_update.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""
+Daily updater for commanderzee/1s-crypto-data
+==============================================
+Checks the latest timestamp in each asset's combined Parquet,
+downloads any missing daily 1s files from Binance Vision, and
+appends them to the HuggingFace dataset.
+
+Run this script daily (e.g. via a cron job, Replit workflow, or HF Space).
+
+Binance daily endpoint:
+  https://data.binance.vision/data/spot/daily/klines/{SYMBOL}/1s/{SYMBOL}-1s-YYYY-MM-DD.zip
+
+Usage:
+  HF_TOKEN=<your_token> python daily_update.py
+  python daily_update.py --dry-run     # show what would be downloaded, no upload
+"""
+
+import argparse
+import datetime
+import gc
+import io
+import os
+import sys
+import time
+import zipfile
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+import requests
+from huggingface_hub import HfApi, hf_hub_download
+
+# ── Config ────────────────────────────────────────────────────────────────────
+REPO_ID       = "commanderzee/1s-crypto-data"
+HF_TOKEN      = os.environ.get("HF_TOKEN", "")
+BINANCE_DAILY = "https://data.binance.vision/data/spot/daily/klines"
+
+SYMBOLS = ["BTCUSDT", "ETHUSDT", "BNBUSDT", "XRPUSDT", "DOGEUSDT", "SOLUSDT"]
+
+PA_SCHEMA = pa.schema([
+    ("open_time_s", pa.int64()),
+    ("open",        pa.float64()),
+    ("high",        pa.float64()),
+    ("low",         pa.float64()),
+    ("close",       pa.float64()),
+    ("volume",      pa.float64()),
+])
+
+
+def download_daily(symbol: str, date: datetime.date, retries: int = 3):
+    """Download one day of 1s data from Binance Vision. Returns DataFrame or None."""
+    fname = f"{symbol}-1s-{date:%Y-%m-%d}.zip"
+    url   = f"{BINANCE_DAILY}/{symbol}/1s/{fname}"
+    for attempt in range(retries):
+        try:
+            r = requests.get(url, timeout=120)
+            if r.status_code == 404:
+                return None          # day not published yet
+            r.raise_for_status()
+            with zipfile.ZipFile(io.BytesIO(r.content)) as z:
+                with z.open(z.namelist()[0]) as f:
+                    df = pd.read_csv(
+                        f, header=None,
+                        usecols=[0, 1, 2, 3, 4, 5],
+                        names=["open_time", "open", "high", "low", "close", "volume"],
+                        dtype={
+                            "open_time": np.int64,
+                            "open":   np.float64,
+                            "high":   np.float64,
+                            "low":    np.float64,
+                            "close":  np.float64,
+                            "volume": np.float64,
+                        }
+                    )
+            sample  = df["open_time"].iloc[0]
+            divisor = 1_000_000 if sample > 2e12 else 1_000
+            df["open_time_s"] = (df["open_time"] // divisor).astype(np.int64)
+            return df[["open_time_s", "open", "high", "low", "close", "volume"]]
+        except Exception as e:
+            if attempt == retries - 1:
+                print(f"    ERROR downloading {symbol} {date}: {e}")
+                return None
+            time.sleep(3)
+
+
+def update_symbol(symbol: str, api: HfApi, dry_run: bool = False) -> int:
+    """
+    Update one asset's combined Parquet with any missing days.
+    Returns number of new rows appended.
+    """
+    hf_path = f"data/{symbol}_1s.parquet"
+    print(f"\n  {'─'*50}")
+    print(f"  {symbol}")
+
+    # Download existing combined Parquet from HF
+    print(f"  Fetching existing parquet from HF...", flush=True)
+    try:
+        local_existing = hf_hub_download(
+            repo_id=REPO_ID,
+            filename=hf_path,
+            repo_type="dataset",
+            token=HF_TOKEN,
+            force_download=True,    # always get freshest version
+        )
+        existing = pd.read_parquet(local_existing)
+    except Exception as e:
+        print(f"  Could not fetch existing file: {e}")
+        return 0
+
+    latest_ts  = existing["open_time_s"].max()
+    latest_dt  = datetime.datetime.utcfromtimestamp(latest_ts).date()
+    print(f"  Latest data: {latest_dt}  ({len(existing):,} rows)")
+
+    # Determine missing days: day after latest through yesterday UTC
+    yesterday = datetime.datetime.utcnow().date() - datetime.timedelta(days=1)
+    missing   = [latest_dt + datetime.timedelta(days=d)
+                 for d in range(1, (yesterday - latest_dt).days + 1)]
+
+    if not missing:
+        print(f"  Already up to date (latest={latest_dt}, yesterday={yesterday})")
+        return 0
+
+    print(f"  Missing {len(missing)} day(s): {missing[0]} → {missing[-1]}")
+    if dry_run:
+        print(f"  [DRY RUN] would download {len(missing)} days — no upload")
+        return 0
+
+    # Download missing days
+    new_frames = []
+    for d in missing:
+        df = download_daily(symbol, d)
+        if df is None:
+            print(f"    {d}: not yet available — stopping here")
+            break
+        new_frames.append(df)
+        print(f"    {d}: {len(df):,} rows downloaded", flush=True)
+
+    if not new_frames:
+        print(f"  No new data available")
+        return 0
+
+    new_data  = pd.concat(new_frames, ignore_index=True)
+    n_new     = len(new_data)
+    combined  = (pd.concat([existing, new_data], ignore_index=True)
+                   .drop_duplicates("open_time_s")
+                   .sort_values("open_time_s")
+                   .reset_index(drop=True))
+    del existing, new_data, new_frames; gc.collect()
+
+    latest_after = datetime.datetime.utcfromtimestamp(
+        combined["open_time_s"].max()).date()
+
+    # Write and upload
+    local_out = Path(f"/tmp/{symbol}_1s_updated.parquet")
+    table     = pa.Table.from_pandas(combined, schema=PA_SCHEMA, preserve_index=False)
+    pq.write_table(table, local_out, compression="snappy")
+    file_mb   = local_out.stat().st_size / 1e6
+    del combined, table; gc.collect()
+
+    print(f"  Uploading {file_mb:.0f} MB ({n_new:+,} new rows, now up to {latest_after})...",
+          flush=True)
+    api.upload_file(
+        path_or_fileobj=str(local_out),
+        path_in_repo=hf_path,
+        repo_id=REPO_ID,
+        repo_type="dataset",
+        commit_message=f"Daily update {symbol}: add {n_new:,} rows through {latest_after}",
+    )
+    local_out.unlink()
+    print(f"  Done: +{n_new:,} rows → {latest_after}")
+    return n_new
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Daily updater for 1s crypto dataset")
+    parser.add_argument("--dry-run",  action="store_true",
+                        help="Show what would be downloaded without uploading")
+    parser.add_argument("--symbols",  nargs="+", default=SYMBOLS,
+                        help="Only update these symbols (default: all 6)")
+    args = parser.parse_args()
+
+    if not HF_TOKEN and not args.dry_run:
+        print("ERROR: HF_TOKEN environment variable not set")
+        sys.exit(1)
+
+    api = HfApi(token=HF_TOKEN)
+
+    print(f"{'='*55}")
+    print(f"  1s Crypto Dataset — Daily Updater")
+    print(f"  {datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M UTC')}")
+    print(f"{'='*55}")
+
+    total_new = 0
+    for symbol in args.symbols:
+        try:
+            n = update_symbol(symbol, api, dry_run=args.dry_run)
+            total_new += n
+        except Exception as e:
+            print(f"  ERROR updating {symbol}: {e}")
+
+    print(f"\n{'='*55}")
+    print(f"  Update complete — {total_new:,} total new rows added")
+    print(f"{'='*55}")
+
+
+if __name__ == "__main__":
+    main()