artifactLink(artifact): string

const link = artifactLink(myArtifact);
console.log(View artifact: ${link});
// Output: https://wandb.ai/entity/project/artifacts/type/name

const artifacts = project.artifacts();
const markdown = artifacts.map(a => 
  - ${artifactName(a)}})
).join('\n');

artifactName(artifact): string

artifacts.forEach(artifact => {
  console.log(Artifact: ${artifactName(artifact)});
});

const modelArtifacts = artifacts.filter(a => 
  artifactName(a).includes("model")
);

artifactVersionAlias(version): string

const prodVersion = versions.find(v => 
  artifactVersionAlias(v) === "production"
);

artifactVersionCreatedAt(version): Date

const sorted = versions.sort((a, b) => 
  artifactVersionCreatedAt(a).getTime() - 
  artifactVersionCreatedAt(b).getTime()
);

artifactVersionDigest(version): string

const digest = artifactVersionDigest(version);
const expected = "sha256:abc123...";
if (digest !== expected) {
  console.error("Artifact integrity check failed!");
}

artifactVersionNumber(version): number

const versions = artifactVersions(artifact);
const maxVersion = Math.max(...versions.map(v => 
  artifactVersionNumber(v)
));
console.log(Latest version: v${maxVersion});

artifactVersionSize(version): number

const bytes = artifactVersionSize(version);
const mb = (bytes / 1e6).toFixed(2);
console.log(Size: ${mb} MB);

const largeVersions = versions.filter(v => 
  artifactVersionSize(v) > 1e9 // > 1GB
);

artifactVersions(artifact): ArtifactVersion[]

const versions = artifactVersions(myArtifact);
versions.forEach(v => {
  console.log(v${v.version}: ${v.alias} (${v.size} bytes));
});

const versions = artifactVersions(artifact);
const latest = versions.find(v => v.alias === "latest");
if (latest) {
  console.log(Latest is v${latest.version});
}

const versions = artifactVersions(artifact);
const totalSize = versions.reduce((sum, v) => sum + v.size, 0);
console.log(Total storage: ${(totalSize / 1e9).toFixed(2)} GB);

runConfig(run): ConfigDict

const config = runConfig(myRun);
console.log(config.learning_rate); // 0.001
console.log(config.batch_size);    // 32

// Find all runs with learning rate > 0.01
const highLRRuns = runs.filter(run => {
  const config = runConfig(run);
  return config.learning_rate > 0.01;
});

const config1 = runConfig(baseline);
const config2 = runConfig(experiment);
const differences = Object.keys(config1).filter(key => 
  config1[key] !== config2[key]
);

runCreatedAt(run): Date

const oneWeekAgo = new Date();
oneWeekAgo.setDate(oneWeekAgo.getDate() - 7);

const recentRuns = runs.filter(run => 
  runCreatedAt(run) > oneWeekAgo
);

const sortedRuns = runs.sort((a, b) => 
  runCreatedAt(a).getTime() - runCreatedAt(b).getTime()
);

const runsByDate = runs.reduce((groups, run) => {
  const date = runCreatedAt(run).toDateString();
  groups[date] = groups[date] || [];
  groups[date].push(run);
  return groups;
}, {});

runHeartbeatAt(run): Date

const isActive = (run: Run) => {
  const lastHeartbeat = runHeartbeatAt(run);
  const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
  return lastHeartbeat > fiveMinutesAgo;
};

runJobType(run): string | undefined

const trainingRuns = runs.filter(run => 
  runJobType(run) === "train"
);
const evalRuns = runs.filter(run => 
  runJobType(run) === "eval"
);

runLoggedArtifactVersion(run, artifactVersionName): ArtifactVersion | undefined

const model = runLoggedArtifactVersion(run, "model:latest");
if (model) {
  console.log(Model version: v${model.version});
  console.log(Model size: ${model.size} bytes);
  console.log(Created: ${model.createdAt});
}

const requiredOutputs = ["model:latest", "evaluation:latest"];
const missing = requiredOutputs.filter(name => 
  !runLoggedArtifactVersion(run, name)
);
if (missing.length > 0) {
  console.warn(Missing outputs: ${missing.join(", ")});
}

runLoggedArtifactVersions(run): ArtifactVersion[]

const outputs = runLoggedArtifactVersions(run);
outputs.forEach(artifact => {
  console.log(Logged: ${artifact.name}:${artifact.alias});
  console.log(  Version: ${artifact.version});
  console.log(  Size: ${artifact.size} bytes);
});

const outputs = runLoggedArtifactVersions(run);
const modelCount = outputs.filter(a => a.name.includes("model")).length;
const dataCount = outputs.filter(a => a.name.includes("data")).length;
console.log(Models: ${modelCount}, Datasets: ${dataCount});

runName(run): string

runs.forEach(run => {
  console.log(Run: ${runName(run)});
});

runRuntime(run): number

const runtime = runRuntime(myRun);
const hours = Math.floor(runtime / 3600);
const minutes = Math.floor((runtime % 3600) / 60);
console.log(Runtime: ${hours}h ${minutes}m);

const longRuns = runs.filter(run => 
  runRuntime(run) > 3600 // More than 1 hour
);

runSummary(run): SummaryDict

const summary = runSummary(myRun);
console.log(Final accuracy: ${summary.accuracy});
console.log(Best validation loss: ${summary.best_val_loss});
console.log(Training time: ${summary.training_time_seconds});

const bestRun = runs.reduce((best, current) => {
  const bestSummary = runSummary(best);
  const currentSummary = runSummary(current);
  return currentSummary.accuracy > bestSummary.accuracy ? current : best;
});

const goodRuns = runs.filter(run => {
  const summary = runSummary(run);
  return summary.accuracy > 0.95 && summary.val_loss < 0.1;
});

runUsedArtifactVersions(run): ArtifactVersion[]

const inputs = runUsedArtifactVersions(run);
console.log("Run dependencies:");
inputs.forEach(artifact => {
  console.log(- ${artifact.name}:${artifact.version});
});

const inputs = runUsedArtifactVersions(run);
const dataset = inputs.find(a => a.name === "training-data");
if (dataset && dataset.version !== 3) {
  console.warn(Using outdated dataset v${dataset.version});
}

runUser(run): User

const myRuns = runs.filter(run => 
  runUser(run).username === "john_doe"
);

const runsByUser = runs.reduce((groups, run) => {
  const user = runUser(run).username;
  groups[user] = groups[user] || [];
  groups[user].push(run);
  return groups;
}, {});