vesper-wizard 2.3.1 → 2.3.2

package/build/metadata/store.js

@@ -1,340 +0,0 @@
-import Database from "better-sqlite3";
-import path from "path";
-import fs from "fs";
-export class MetadataStore {
-    db;
-    constructor(dbPath) {
-        // Ensure data directory exists
-        const dir = path.dirname(dbPath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        this.db = new Database(dbPath);
-        this.init();
-        this.migrate();
-    }
-    migrate() {
-        // Add install_path if missing
-        try {
-            this.db.exec("ALTER TABLE datasets ADD COLUMN install_path TEXT");
-            console.error("[MetadataStore] Migrated: Added install_path column");
-        }
-        catch (e) {
-            // Probably already exists
-        }
-    }
-    init() {
-        // Create table with all columns if it doesn't exist
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS datasets (
-        id TEXT PRIMARY KEY,
-        source TEXT, -- 'huggingface', 'kaggle', 'uci', etc.
-        name TEXT,
-        description TEXT,
-        downloads INTEGER,
-        likes INTEGER,
-        stars INTEGER,
-        tags TEXT, -- JSON string
-        license_id TEXT,
-        license_category TEXT,
-        quality_score INTEGER,
-        has_train_split BOOLEAN,
-        total_examples INTEGER,
-        total_size_mb REAL,
-        is_safe_source BOOLEAN,
-        is_structured BOOLEAN,
-        last_updated TEXT,
-        quality_warnings TEXT, -- JSON array string
-        metadata_json TEXT, -- Full metadata as JSON
-        install_path TEXT -- Path to locally installed data
-      );
-
-      CREATE TABLE IF NOT EXISTS jobs (
-        id TEXT PRIMARY KEY,
-        type TEXT,
-        status TEXT,
-        priority INTEGER DEFAULT 0,
-        progress INTEGER DEFAULT 0,
-        status_text TEXT,
-        result_url TEXT,
-        error TEXT,
-        attempts INTEGER DEFAULT 0,
-        max_attempts INTEGER DEFAULT 3,
-        created_at TEXT,
-        updated_at TEXT,
-        metadata TEXT
-      );
-
-      CREATE TABLE IF NOT EXISTS local_files (
-        id TEXT PRIMARY KEY,
-        local_path TEXT,
-        status TEXT, -- 'downloading', 'completed', 'failed'
-        size_bytes INTEGER,
-        last_checked TEXT,
-        error TEXT
-      );
-
-      CREATE TABLE IF NOT EXISTS jobs_archive (
-        id TEXT PRIMARY KEY,
-        type TEXT,
-        status TEXT,
-        priority INTEGER DEFAULT 0,
-        progress INTEGER DEFAULT 0,
-        status_text TEXT,
-        result_url TEXT,
-        error TEXT,
-        attempts INTEGER DEFAULT 0,
-        max_attempts INTEGER DEFAULT 3,
-        created_at TEXT,
-        updated_at TEXT,
-        metadata TEXT
-      );
-    `);
-        // Migrate existing tables: add new columns if they don't exist
-        const tableInfo = this.db.prepare("PRAGMA table_info(datasets)").all();
-        const existingColumns = new Set(tableInfo.map(col => col.name));
-        const migrations = [
-            { column: "stars", type: "INTEGER DEFAULT 0" },
-            { column: "total_examples", type: "INTEGER" },
-            { column: "total_size_mb", type: "REAL" },
-            { column: "is_safe_source", type: "BOOLEAN DEFAULT 1" },
-            { column: "is_structured", type: "BOOLEAN DEFAULT 0" },
-            { column: "domain", type: "TEXT" },
-            { column: "source", type: "TEXT DEFAULT 'huggingface'" },
-            { column: "quality_warnings", type: "TEXT" }
-        ];
-        for (const migration of migrations) {
-            if (!existingColumns.has(migration.column)) {
-                console.error(`[MetadataStore] Migrating: adding column ${migration.column}`);
-                this.db.exec(`ALTER TABLE datasets ADD COLUMN ${migration.column} ${migration.type}`);
-            }
-        }
-        // Job migrations
-        const jobTableInfo = this.db.prepare("PRAGMA table_info(jobs)").all();
-        const existingJobColumns = new Set(jobTableInfo.map(col => col.name));
-        const jobMigrations = [
-            { column: "priority", type: "INTEGER DEFAULT 0" },
-            { column: "attempts", type: "INTEGER DEFAULT 0" },
-            { column: "max_attempts", type: "INTEGER DEFAULT 3" }
-        ];
-        for (const migration of jobMigrations) {
-            if (!existingJobColumns.has(migration.column)) {
-                console.error(`[MetadataStore] Migrating Job: adding column ${migration.column}`);
-                this.db.exec(`ALTER TABLE jobs ADD COLUMN ${migration.column} ${migration.type}`);
-            }
-        }
-        // Get updated column list after migrations
-        const updatedTableInfo = this.db.prepare("PRAGMA table_info(datasets)").all();
-        const allColumns = new Set(updatedTableInfo.map(col => col.name));
-        // Create indexes (only if columns exist)
-        const indexes = [
-            { name: "idx_license_category", table: "datasets", column: "license_category" },
-            { name: "idx_quality_score", table: "datasets", column: "quality_score" },
-            { name: "idx_downloads", table: "datasets", column: "downloads" },
-            { name: "idx_has_train_split", table: "datasets", column: "has_train_split" },
-            { name: "idx_is_safe_source", table: "datasets", column: "is_safe_source" },
-            { name: "idx_is_structured", table: "datasets", column: "is_structured" },
-            { name: "idx_domain", table: "datasets", column: "domain" },
-            { name: "idx_jobs_status", table: "jobs", column: "status" },
-            { name: "idx_jobs_created", table: "jobs", column: "created_at" },
-            { name: "idx_jobs_archive_created", table: "jobs_archive", column: "created_at" }
-        ];
-        for (const idx of indexes) {
-            // For datasets table, check if column exists first
-            if (idx.table === "datasets" && !allColumns.has(idx.column))
-                continue;
-            try {
-                this.db.exec(`CREATE INDEX IF NOT EXISTS ${idx.name} ON ${idx.table}(${idx.column})`);
-            }
-            catch (e) {
-                // Ignore index errors
-            }
-        }
-    }
-    saveDataset(dataset) {
-        // If the incoming dataset is incomplete, check if we already have a complete one
-        if (dataset.is_incomplete) {
-            const existing = this.getDataset(dataset.id);
-            if (existing && !existing.is_incomplete) {
-                // Already have better data, only update stats
-                const updateStats = this.db.prepare(`
-                    UPDATE datasets SET
-                        downloads = ?,
-                        likes = ?,
-                        stars = ?,
-                        last_updated = ?
-                    WHERE id = ?
-                `);
-                updateStats.run(dataset.downloads, dataset.likes, dataset.stars || 0, dataset.last_updated, dataset.id);
-                return;
-            }
-        }
-        const stmt = this.db.prepare(`
-      INSERT INTO datasets (
-        id, source, name, description, downloads, likes, stars, tags, 
-        license_id, license_category, quality_score, 
-        has_train_split, total_examples, total_size_mb,
-        is_safe_source, is_structured, last_updated, 
-        quality_warnings, metadata_json, install_path
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(id) DO UPDATE SET
-        source=excluded.source,
-        name=excluded.name,
-        description=excluded.description,
-        downloads=excluded.downloads,
-        likes=excluded.likes,
-        stars=excluded.stars,
-        tags=excluded.tags,
-        license_id=excluded.license_id,
-        license_category=excluded.license_category,
-        quality_score=excluded.quality_score,
-        has_train_split=excluded.has_train_split,
-        total_examples=excluded.total_examples,
-        total_size_mb=excluded.total_size_mb,
-        is_safe_source=excluded.is_safe_source,
-        is_structured=excluded.is_structured,
-        last_updated=excluded.last_updated,
-        quality_warnings=excluded.quality_warnings,
-        metadata_json=excluded.metadata_json,
-        install_path=excluded.install_path
-    `);
-        stmt.run(dataset.id, dataset.source, dataset.name, dataset.description, dataset.downloads, dataset.likes, dataset.stars || 0, JSON.stringify(dataset.tags), dataset.license.id, dataset.license.category, dataset.quality_score, dataset.has_train_split ? 1 : 0, dataset.total_examples, dataset.total_size_mb || null, dataset.is_safe_source ? 1 : 0, dataset.is_structured ? 1 : 0, dataset.last_updated, JSON.stringify(dataset.quality_warnings || []), JSON.stringify(dataset), dataset.install_path || null);
-    }
-    updateInstallPath(id, path) {
-        this.db.prepare("UPDATE datasets SET install_path = ? WHERE id = ?").run(path, id);
-    }
-    getDataset(id) {
-        const row = this.db.prepare("SELECT metadata_json, install_path FROM datasets WHERE id = ?").get(id);
-        if (!row)
-            return null;
-        const metadata = JSON.parse(row.metadata_json);
-        metadata.install_path = row.install_path || undefined;
-        return metadata;
-    }
-    getAllDatasets() {
-        const rows = this.db.prepare("SELECT metadata_json FROM datasets").all();
-        return rows.map(r => JSON.parse(r.metadata_json));
-    }
-    beginTransaction() {
-        this.db.exec("BEGIN");
-    }
-    commit() {
-        this.db.exec("COMMIT");
-    }
-    rollback() {
-        this.db.exec("ROLLBACK");
-    }
-    search(options) {
-        let query = "SELECT metadata_json FROM datasets WHERE 1=1";
-        const params = [];
-        if (options.licenseCategories && options.licenseCategories.length > 0) {
-            const placeholders = options.licenseCategories.map(() => "?").join(",");
-            query += ` AND license_category IN (${placeholders})`;
-            params.push(...options.licenseCategories);
-        }
-        if (options.minQualityScore !== undefined) {
-            query += " AND quality_score >= ?";
-            params.push(options.minQualityScore);
-        }
-        query += " ORDER BY quality_score DESC";
-        if (options.limit) {
-            query += " LIMIT ?";
-            params.push(options.limit);
-        }
-        const rows = this.db.prepare(query).all(...params);
-        return rows.map(r => JSON.parse(r.metadata_json));
-    }
-    saveJob(job) {
-        const upsert = this.db.prepare(`
-            INSERT INTO jobs (id, type, status, priority, progress, status_text, result_url, error, attempts, max_attempts, created_at, updated_at, metadata)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(id) DO UPDATE SET
-                status=excluded.status,
-                priority=excluded.priority,
-                progress=excluded.progress,
-                status_text=excluded.status_text,
-                result_url=excluded.result_url,
-                error=excluded.error,
-                attempts=excluded.attempts,
-                max_attempts=excluded.max_attempts,
-                updated_at=excluded.updated_at,
-                metadata=excluded.metadata
-        `);
-        upsert.run(job.id, job.type, job.status, job.priority, job.progress, job.status_text, job.result_url || null, job.error || null, job.attempts, job.max_attempts, job.created_at, job.updated_at, job.metadata || null);
-    }
-    getJob(id) {
-        const row = this.db.prepare("SELECT * FROM jobs WHERE id = ?").get(id);
-        return row || null;
-    }
-    /**
-     * Register or update a local file record
-     */
-    registerDownload(id, localPath, status, sizeBytes, error) {
-        const upsert = this.db.prepare(`
-            INSERT INTO local_files (id, local_path, status, size_bytes, last_checked, error)
-            VALUES (?, ?, ?, ?, ?, ?)
-            ON CONFLICT(id) DO UPDATE SET
-                local_path=excluded.local_path,
-                status=excluded.status,
-                size_bytes=excluded.size_bytes,
-                last_checked=excluded.last_checked,
-                error=excluded.error
-        `);
-        upsert.run(id, localPath, status, sizeBytes || 0, new Date().toISOString(), error || null);
-    }
-    /**
-     * Get download status and path for a dataset
-     */
-    getDownloadStatus(id) {
-        return this.db.prepare("SELECT * FROM local_files WHERE id = ?").get(id);
-    }
-    /**
-     * Archive old jobs to the cold storage table.
-     * @param days Age in days
-     */
-    archiveOldJobs(days) {
-        const cutoff = new Date();
-        cutoff.setDate(cutoff.getDate() - days);
-        const cutoffStr = cutoff.toISOString();
-        return this.db.transaction(() => {
-            // Copy to archive
-            this.db.prepare(`
-                INSERT OR IGNORE INTO jobs_archive 
-                SELECT * FROM jobs 
-                WHERE created_at < ?
-            `).run(cutoffStr);
-            // Delete from active jobs
-            const info = this.db.prepare(`
-                DELETE FROM jobs 
-                WHERE created_at < ?
-            `).run(cutoffStr);
-            return info.changes;
-        })();
-    }
-    /**
-     * Perform database maintenance (VACUUM, ANALYZE).
-     */
-    optimize() {
-        console.error("[MetadataStore] Running database optimization (VACUUM, ANALYZE)...");
-        this.db.exec("VACUUM");
-        this.db.exec("ANALYZE");
-    }
-    /**
-     * Delete all datasets from a specific source
-     */
-    deleteBySource(source) {
-        const info = this.db.prepare("DELETE FROM datasets WHERE source = ?").run(source);
-        console.error(`[MetadataStore] Deleted ${info.changes} datasets from source: ${source}`);
-        return info.changes;
-    }
-    /**
-     * Get all dataset IDs from a specific source
-     */
-    getDatasetIdsBySource(source) {
-        const rows = this.db.prepare("SELECT id FROM datasets WHERE source = ?").all(source);
-        return rows.map(r => r.id);
-    }
-    close() {
-        this.db.close();
-    }
-}

package/build/metadata/types.js

@@ -1 +0,0 @@
-export {};

package/build/metadata/uci-scraper.js

@@ -1,49 +0,0 @@
-import { spawn } from "child_process";
-import path from "path";
-const PYTHON_SCRIPT_PATH = path.resolve("src", "python", "uci_adapter.py");
-export class UCIScraper {
-    /**
-     * Search UCI repository using the Python adapter
-     */
-    async scrape(query, limit = 10) {
-        return new Promise((resolve, reject) => {
-            const pythonProcess = spawn("python", [
-                PYTHON_SCRIPT_PATH,
-                "--action", "search",
-                "--query", query,
-                "--limit", String(limit)
-            ]);
-            let output = "";
-            let errorOutput = "";
-            pythonProcess.stdout.on("data", (data) => {
-                output += data.toString();
-            });
-            pythonProcess.stderr.on("data", (data) => {
-                errorOutput += data.toString();
-            });
-            pythonProcess.on("close", (code) => {
-                if (code !== 0) {
-                    // It's possible for python to emit stderr warnings but still succeed
-                    // But exit code != 0 is definitely an error
-                    console.error(`[UCIScraper] Process exited with code ${code}: ${errorOutput}`);
-                    resolve([]); // Fail gracefully by returning empty
-                    return;
-                }
-                try {
-                    const results = JSON.parse(output);
-                    if (results.error) {
-                        console.error(`[UCIScraper] Internal error: ${results.error}`);
-                        resolve([]);
-                    }
-                    else {
-                        resolve(results);
-                    }
-                }
-                catch (e) {
-                    console.error(`[UCIScraper] JSON parse error: ${e.message}. Output: ${output.substring(0, 100)}...`);
-                    resolve([]);
-                }
-            });
-        });
-    }
-}

package/build/monitoring/observability.js

@@ -1,76 +0,0 @@
-export class MockErrorTracker {
-    exceptions = [];
-    messages = [];
-    captureException(error, context) {
-        console.error(`[ErrorTracker] Exception captured: ${error.message}`);
-        this.exceptions.push({ error, context });
-    }
-    captureMessage(message, level = "info") {
-        console.error(`[ErrorTracker] Message captured (${level}): ${message}`);
-        this.messages.push({ message, level });
-    }
-}
-export class ObservabilityService {
-    errorTracker;
-    jobSuccessCounter = new Map();
-    jobFailureCounter = new Map();
-    jobDurationHistogram = new Map();
-    constructor(errorTracker = new MockErrorTracker()) {
-        this.errorTracker = errorTracker;
-    }
-    recordJobSuccess(type, durationMs) {
-        // Increment success counter
-        this.jobSuccessCounter.set(type, (this.jobSuccessCounter.get(type) || 0) + 1);
-        // Record duration
-        this.updateMetricRecord(type, durationMs);
-    }
-    recordJobFailure(type, error) {
-        // Increment failure counter
-        this.jobFailureCounter.set(type, (this.jobFailureCounter.get(type) || 0) + 1);
-        // Track error
-        this.errorTracker.captureException(error, { jobType: type });
-    }
-    getPrometheusMetrics() {
-        let out = "# HELP jobs_processed_total Total number of jobs successfully processed\n";
-        out += "# TYPE jobs_processed_total counter\n";
-        for (const [type, count] of this.jobSuccessCounter) {
-            out += `jobs_processed_total{type="${type}"} ${count}\n`;
-        }
-        out += "\n# HELP jobs_failed_total Total number of failed jobs\n";
-        out += "# TYPE jobs_failed_total counter\n";
-        for (const [type, count] of this.jobFailureCounter) {
-            out += `jobs_failed_total{type="${type}"} ${count}\n`;
-        }
-        out += "\n# HELP job_duration_seconds_sum Latency of job processing in seconds\n";
-        out += "# TYPE job_duration_seconds_sum counter\n";
-        for (const [type, record] of this.jobDurationHistogram) {
-            out += `job_duration_seconds_sum{type="${type}"} ${record.sum / 1000}\n`;
-            out += `job_duration_seconds_count{type="${type}"} ${record.count}\n`;
-            out += `job_duration_seconds_max{type="${type}"} ${record.max / 1000}\n`;
-        }
-        return out;
-    }
-    getStats() {
-        const stats = {};
-        for (const [type, record] of this.jobDurationHistogram) {
-            stats[type] = {
-                successCount: this.jobSuccessCounter.get(type) || 0,
-                failureCount: this.jobFailureCounter.get(type) || 0,
-                avgDuration: (record.sum / record.count).toFixed(2) + "ms",
-                maxDuration: record.max + "ms"
-            };
-        }
-        return stats;
-    }
-    updateMetricRecord(type, value) {
-        let record = this.jobDurationHistogram.get(type);
-        if (!record) {
-            record = { count: 0, sum: 0, min: value, max: value };
-            this.jobDurationHistogram.set(type, record);
-        }
-        record.count++;
-        record.sum += value;
-        record.min = Math.min(record.min, value);
-        record.max = Math.max(record.max, value);
-    }
-}

package/build/preparation/target-detector.js

@@ -1,75 +0,0 @@
-import { spawn } from "child_process";
-import path from "path";
-import fs from "fs";
-export class TargetDetector {
-    pythonPath = "python";
-    scriptPath;
-    constructor(buildDir = process.cwd()) {
-        const homeDir = process.env.HOME || process.env.USERPROFILE || buildDir;
-        const dataRoot = path.join(homeDir, ".vesper");
-        // Use same robust path resolution as other services
-        const scriptPath0 = path.resolve(dataRoot, "python", "target_engine.py");
-        const scriptPath1 = path.resolve(buildDir, "python", "target_engine.py");
-        const scriptPath2 = path.resolve(buildDir, "..", "src", "python", "target_engine.py");
-        const scriptPath3 = path.resolve(buildDir, "..", "python", "target_engine.py");
-        if (fs.existsSync(scriptPath0)) {
-            this.scriptPath = scriptPath0;
-        }
-        else if (fs.existsSync(scriptPath1)) {
-            this.scriptPath = scriptPath1;
-        }
-        else if (fs.existsSync(scriptPath2)) {
-            this.scriptPath = scriptPath2;
-        }
-        else if (fs.existsSync(scriptPath3)) {
-            this.scriptPath = scriptPath3;
-        }
-        else {
-            this.scriptPath = scriptPath0;
-        }
-        if (process.platform === "win32") {
-            this.pythonPath = "py";
-        }
-    }
-    /**
-     * Detect probable target columns in a dataset
-     */
-    async detectTarget(filePath) {
-        return this.runPython("detect", [filePath]);
-    }
-    /**
-     * Validate a specific column as a target
-     */
-    async validateTarget(filePath, targetColumn) {
-        return this.runPython("validate", [filePath, targetColumn]);
-    }
-    async runPython(action, args) {
-        return new Promise((resolve, reject) => {
-            const childProcess = spawn(this.pythonPath, [this.scriptPath, action, ...args], {
-                env: { ...process.env, PYTHONIOENCODING: 'utf-8' }
-            });
-            let stdout = "";
-            let stderr = "";
-            childProcess.stdout.on("data", (data) => stdout += data.toString());
-            childProcess.stderr.on("data", (data) => stderr += data.toString());
-            childProcess.on("close", (code) => {
-                if (code !== 0) {
-                    reject(new Error(`Target Detector (${action}) failed: ${stderr}`));
-                    return;
-                }
-                try {
-                    const result = JSON.parse(stdout);
-                    if (result.error) {
-                        reject(new Error(result.error));
-                    }
-                    else {
-                        resolve(result);
-                    }
-                }
-                catch (e) {
-                    reject(new Error(`Failed to parse target detector output: ${stdout}\nError: ${e}`));
-                }
-            });
-        });
-    }
-}

package/build/python/asset_downloader_engine.py

@@ -1,94 +0,0 @@
-import argparse
-import asyncio
-import json
-import os
-import sys
-import warnings
-from pathlib import Path
-from typing import Any, Dict
-
-# Suppress noisy HF warnings
-warnings.filterwarnings("ignore", message=".*trust_remote_code.*")
-warnings.filterwarnings("ignore", message=".*legacy.*")
-
-CURRENT_DIR = Path(__file__).resolve().parent
-if str(CURRENT_DIR) not in sys.path:
-    sys.path.insert(0, str(CURRENT_DIR))
-
-from vesper.core.asset_downloader import AssetDownloader
-from vesper.core.download_recipe import build_download_recipe, save_recipe, get_download_recipe
-
-
-def _print(payload: Dict[str, Any]) -> None:
-    print(json.dumps(payload, ensure_ascii=False))
-
-
-async def _run_download(args: argparse.Namespace) -> Dict[str, Any]:
-    payload = json.loads(args.payload)
-    output_root = payload.get("output_root") or str(Path.home() / ".vesper" / "data" / "assets")
-    output_dir = payload.get("output_dir")
-    workers = int(payload.get("workers") or 8)
-    recipes_dir = payload.get("recipes_dir")
-
-    # Auto-set HF token from payload if provided
-    token = payload.get("token") or payload.get("hf_token")
-    if token:
-        os.environ["HF_TOKEN"] = str(token)
-
-    downloader = AssetDownloader(output_root=output_root, workers=workers, recipes_dir=recipes_dir)
-
-    result = await downloader.download_assets(
-        dataset_id=str(payload.get("dataset_id")),
-        source=payload.get("source"),
-        repo_id=payload.get("repo_id"),
-        kaggle_ref=payload.get("kaggle_ref"),
-        urls=payload.get("urls"),
-        output_format=payload.get("output_format", "webdataset"),
-        output_dir=str(output_dir) if output_dir else None,
-        max_items=payload.get("max_items"),
-        image_column=payload.get("image_column"),
-    )
-    return {"ok": True, "result": result}
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Vesper Smart Asset Downloader Engine")
-    parser.add_argument("action", choices=["download", "build_recipe", "get_recipe"])
-    parser.add_argument("payload", help="JSON payload")
-    args = parser.parse_args()
-
-    try:
-        if args.action == "download":
-            response = asyncio.run(_run_download(args))
-            _print(response)
-            return
-
-        payload = json.loads(args.payload)
-        if args.action == "build_recipe":
-            recipe = build_download_recipe(payload)
-            saved = save_recipe(recipe, payload.get("recipes_dir"))
-            _print({"ok": True, "recipe": recipe, "saved_to": saved})
-            return
-
-        if args.action == "get_recipe":
-            dataset_id = str(payload.get("dataset_id"))
-            recipe = get_download_recipe(dataset_id, payload.get("recipes_dir"))
-            _print({"ok": True, "recipe": recipe})
-            return
-
-        _print({"ok": False, "error": f"Unknown action: {args.action}"})
-    except Exception as e:
-        error_msg = str(e)
-        # Provide actionable error messages
-        if "401" in error_msg or "403" in error_msg or "Unauthorized" in error_msg:
-            error_msg = (
-                "Authentication required. This dataset may be gated/private. "
-                "Use configure_keys tool to set HF_TOKEN, then retry."
-            )
-        elif "No image column" in error_msg:
-            error_msg += " Hint: specify image_column parameter with the name of the column containing images."
-        _print({"ok": False, "error": error_msg})
-
-
-if __name__ == "__main__":
-    main()