Datasets: methods

interface Dataset {
  name: string;
  title: string | null;
  description: string | null;
  active_version: DatasetVersion | null;
  latest_version: DatasetVersion | null;
  versions?: DatasetVersion[];
  selected_version?: DatasetVersion | null;
  tasks?: Page<Task>;
  failed_tasks?: DatasetFailedTask[];
  lint?: EnvLintSummary | null;
  upstream: UpstreamStatus | null;
  created_at?: string;
  updated_at?: string;
}

interface ActiveDataset {
  name: string;
  title: string | null;
  description: string | null;
  active_version: DatasetVersion;
  version: string;
  tasks: Page<Task>;
  versions: DatasetVersion[];
  created_at: string;
  updated_at: string;
}

interface DatasetVersion {
  version: string;
  state: DatasetVersionState;
  created_at: string;
  task_count: number;
  n_failed_tasks: number;
  manifest: DatasetManifestMetadata | null;
  source: DatasetVersionSource | null;
}

interface Task {
  task_name: string;
  agent_timeout_sec: number;
  verifier_timeout_sec: number;
  gpus?: number;
  gpu_types?: string[] | null;
  providers: Record<EvalSandboxProvider, TaskProviderVerdict>;
  notes: TaskNote[];
  lint?: EnvLintFinding[];
}

type TaskProviderVerdict =
  | { ok: true; degrades_to?: "modal"; reason?: string }
  | { ok: false; reason: string };

interface TaskNote {
  code: "tests_dockerfile_not_built";
  message: string;
}

interface DatasetFailedTask {
  task_name: string;
  failure: TaskBuildFailure;
}

interface TaskBuild {
  task_name: string;
  state: TaskBuildState;
  failure: TaskBuildFailure | null;
}

interface TaskBuildFailure {
  code: string;
  step: string;
  message: string;
  excerpt?: string | null;
}

interface DatasetManifestAuthor {
  name: string;
  email: string | null;
}

interface DatasetManifestMetadata {
  name: string;
  version: string | null;
  description: string;
  authors: DatasetManifestAuthor[];
  keywords: string[];
  task_count: number | null;
}

interface DatasetVersionGitSource {
  kind: "git";
  git_url: string | null;
  ref: string;
  commit: string;
  path: string | null;
}

interface DatasetVersionArchiveSource {
  kind: "archive";
  digest: string;
}

interface DatasetVersionArchiveUrlSource {
  kind: "archive_url";
  archive_url: string;
  digest: string;
}

interface DatasetVersionHubSource {
  kind: "hub_package";
  hub_package: string;
  digest: string;
}

type DatasetVersionSource =
  | DatasetVersionGitSource
  | DatasetVersionArchiveSource
  | DatasetVersionArchiveUrlSource
  | DatasetVersionHubSource;

interface UpstreamStatus {
  git_url?: string | null;
  ref: string;
  current_commit: string;
  path?: string | null;
  latest_commit: string | null;
  acked_commit?: string | null;
  moved: boolean;
  behind_by: number | null;
  checked_at: string | null;
  error: string | null;
  auto_import: boolean;
}

interface DatasetPreflight {
  importer_version: string;
  harbor_support?: HarborSupport;
  harbor_format?: HarborFormatFootprint | null;
  checks: string[];
  deferred: PreflightDeferredCheck[];
  manifest: PreflightManifestVerdict | null;
  tasks: PreflightTaskVerdict[];
  tasks_total: number;
  tasks_ok: number;
  tasks_refused: number;
}

interface PreflightTaskVerdict {
  name: string;
  ok: boolean;
  task_key: string;
  schema_version?: string;
  harbor_format?: HarborFormatFootprint;
  providers?: Record<EvalSandboxProvider, TaskProviderVerdict>;
  notes?: TaskNote[];
  reason?: string;
}

interface HarborSupport {
  supported_through: string;      // e.g. "v0.25.0"
  supported_through_date: string;
  window_start: string;           // e.g. "v0.6.0"
  window_start_date: string;
  latest_schema_version: string;  // e.g. "1.4"
  schema_versions: string[];
}

interface HarborFormatFootprint {
  // e.g. "v0.14.0"; "pre-v0.3.0" means Harbor 0.1.x-0.2.x.
  requires_harbor: string;
  requires_harbor_date: string;
  newest_fields: string[];        // e.g. ["verifier.collect"]
}

interface PreflightDeferredCheck {
  name: string;
  reads: string;
}

interface PreflightManifestVerdict {
  ok: boolean;
  name?: string;
  short_name?: string;
  version?: string | null;
  task_count?: number;
  reason?: string;
}

interface DatasetImport {
  id: string;
  status: DatasetImportStatus;
  receiving?: boolean;
  name: string;
  version: string;
  failure: DatasetImportFailure | null;
  warnings: ImportWarning[];
  progress: DatasetImportProgress | null;
  lint?: EnvLintSummary | null;
  task_count?: number;
  created_at?: string;
  updated_at?: string;
}

interface DatasetImportFailure {
  code: string;
  message: string;
  failures?: { task_name: string; error: string }[];
}

interface ImportWarning {
  code:
    | "solutions_archiving_disabled"
    | "no_solutions_archived"
    | "partial_solutions_archived"
    | "tasks_failed_to_build"
    | "tests_dockerfile_not_built"
    | "environment_lint_findings";
  message?: string;
}

interface EnvLintSummary {
  linter: string;
  tasks_linted: number;
  errors: number;
  warnings: number;
  infos: number;
  tasks_with_errors: number;
  tasks_with_warnings: number;
  rules: EnvLintRuleSummary[];
  truncated: boolean;
  infos_truncated?: boolean;
}

interface EnvLintRuleSummary {
  rule: EnvLintRuleId;
  severity: EnvLintSeverity;
  title: string;
  fix: string;
  tasks: number;
  template_wide: boolean;
}

interface EnvLintFinding {
  rule: EnvLintRuleId;
  severity: EnvLintSeverity;
  message: string;
  file?: string;
  line?: number;
  evidence?: string;
}

type EnvLintSeverity = "error" | "warning" | "info";

type ImportPhase =
  | "extracting"
  | "parsing"
  | "building"
  | "copying"
  | "verifying";

interface ImportPhaseProgress {
  name: ImportPhase;
  started_at: string;
  completed_at?: string;
  done: number;
  total: number;
  banked?: number;
}

interface DatasetImportProgress {
  phase: ImportPhase;
  started_at: string;
  phases: ImportPhaseProgress[];
  images: { built: number; mirrored: number; banked: number };
  codebuild: { copy_builds: number; billed_minutes: number };
}