dataiku-sdk 3.6.1 → 3.8.0

package/dist/src/cli/commands/ml-task.js

@@ -1,5 +1,6 @@
-import { num, requiredJsonInput, requiredStringFlag, } from "../coerce.js";
+import { num, parseBooleanOption, requiredJsonInput, requiredStringFlag, splitCsvFlag, } from "../coerce.js";
 import { executionMode, } from "../flags.js";
+import { trainedModelCommands, } from "../helpers/trained-model.js";
 import { commandUsage, withUsage, } from "../syntax.js";
 import { requireArgs, UsageError, } from "../usage.js";
 function optionalStringFlag(flags, name) {
@@ -17,27 +18,47 @@ function taskType(flags, usage) {
         return normalized;
     throw new UsageError("--task-type must be PREDICTION or CLUSTERING.", "invalid_enum");
 }
+/** Task definition flags shared by `create`, `create-for-dataset`, and their --plan. */
+export function mlTaskFieldsFromFlags(flags, usage) {
+    const normalizedTaskType = taskType(flags, usage);
+    const targetVariable = optionalStringFlag(flags, "target");
+    if (normalizedTaskType === "PREDICTION" && targetVariable === undefined) {
+        throw new UsageError("--target is required for PREDICTION ML tasks.", "missing_required_flag");
+    }
+    const timeseriesIdentifiers = splitCsvFlag(flags["timeseries-ids"]);
+    return {
+        taskType: normalizedTaskType,
+        targetVariable,
+        predictionType: optionalStringFlag(flags, "prediction-type"),
+        timeVariable: optionalStringFlag(flags, "time-variable"),
+        ...(timeseriesIdentifiers.length > 0 ? { timeseriesIdentifiers, } : {}),
+        backendType: optionalStringFlag(flags, "backend-type"),
+        guessPolicy: optionalStringFlag(flags, "guess-policy"),
+    };
+}
+/** `reguess` flags → SDK options (shared with --plan). */
+export function mlTaskReguessOptionsFromFlags(flags) {
+    const timeseriesIdentifiers = splitCsvFlag(flags["timeseries-ids"]);
+    return {
+        predictionType: optionalStringFlag(flags, "prediction-type"),
+        targetVariable: optionalStringFlag(flags, "target"),
+        timeVariable: optionalStringFlag(flags, "time-variable"),
+        ...(timeseriesIdentifiers.length > 0 ? { timeseriesIdentifiers, } : {}),
+        ...(flags["full-reguess"] !== undefined
+            ? { fullReguess: parseBooleanOption(flags["full-reguess"], "--full-reguess"), }
+            : {}),
+    };
+}
 export const mlTaskCommands = withUsage("ml-task", {
     create: {
         handler: async (c, a, f) => {
             const usage = commandUsage("ml-task", "create");
             requireArgs(a, 1, usage);
-            const projectKey = f["project-key"];
-            const normalizedTaskType = taskType(f, usage);
-            const targetVariable = optionalStringFlag(f, "target");
-            if (normalizedTaskType === "PREDICTION" && targetVariable === undefined) {
-                throw new UsageError("--target is required for PREDICTION ML tasks.", "missing_required_flag");
-            }
-            const options = {
+            const created = await c.mlTasks.create({
                 analysisId: a[0],
-                taskType: normalizedTaskType,
-                targetVariable,
-                predictionType: optionalStringFlag(f, "prediction-type"),
-                backendType: optionalStringFlag(f, "backend-type"),
-                guessPolicy: optionalStringFlag(f, "guess-policy"),
-                projectKey,
-            };
-            const created = await c.mlTasks.create(options);
+                ...mlTaskFieldsFromFlags(f, usage),
+                projectKey: f["project-key"],
+            });
             return { created: created.mlTaskId, resource: "ml-task", analysisId: a[0], ...created, };
         },
         description: "Create a prediction or clustering task in an analysis.",
@@ -173,4 +194,53 @@ export const mlTaskCommands = withUsage("ml-task", {
             "dss ml-task delete ANALYSIS_ID TASK_ID --dry-run --project-key PROJECT",
         ],
     },
+    list: {
+        handler: (c, _a, f) => c.mlTasks.list(f["project-key"]),
+        description: "List every ML task of the project with its visual analysis (one analysis: dss analysis list-ml-tasks).",
+        examples: ["dss ml-task list",],
+    },
+    "create-for-dataset": {
+        handler: async (c, a, f) => {
+            const usage = commandUsage("ml-task", "create-for-dataset");
+            requireArgs(a, 1, usage);
+            const created = await c.mlTasks.createForDataset({
+                inputDataset: a[0],
+                ...mlTaskFieldsFromFlags(f, usage),
+                projectKey: f["project-key"],
+            });
+            return { created: created.mlTaskId, resource: "ml-task", ...created, };
+        },
+        description: "Create a new visual analysis on a dataset with one prediction, clustering, or forecasting task (--prediction-type TIMESERIES_FORECAST --time-variable COL [--timeseries-ids COLS]). DSS guesses settings asynchronously: poll status until guessing is false.",
+        examples: [
+            "dss ml-task create-for-dataset customers --task-type prediction --target churn",
+            "dss ml-task create-for-dataset sales --task-type prediction --target amount --prediction-type TIMESERIES_FORECAST --time-variable day",
+        ],
+    },
+    reguess: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, commandUsage("ml-task", "reguess"));
+            await c.mlTasks.reguess(a[0], a[1], mlTaskReguessOptionsFromFlags(f), f["project-key"]);
+            return { reguessed: a[1], resource: "ml-task", analysisId: a[0], };
+        },
+        description: "Re-guess an ML task's settings: all of them, or after changing one core parameter (--prediction-type, --target, --time-variable, --timeseries-ids), only the impacted ones unless --full-reguess true.",
+        examples: ["dss ml-task reguess ANALYSIS_ID TASK_ID --target churn_flag",],
+    },
+    "reguess-forecasting": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, commandUsage("ml-task", "reguess-forecasting"));
+            await c.mlTasks.reguessForecasting(a[0], a[1], requiredJsonInput(f, "Forecasting parameters are required via --data, --data-file, or --stdin (forecastHorizon, validationHorizons, timestepParams, updateAlgorithmSettings)."), f["project-key"]);
+            return { reguessed: a[1], resource: "ml-task", analysisId: a[0], };
+        },
+        description: "Time series forecasting tasks: change forecasting parameters (forecastHorizon, validationHorizons, timestepParams {timeunit, numberOfTimeunits, ...}, updateAlgorithmSettings) and re-guess impacted algorithm settings.",
+        examples: [
+            'dss ml-task reguess-forecasting ANALYSIS_ID TASK_ID --data \'{"forecastHorizon":7,"updateAlgorithmSettings":true}\'',
+        ],
+    },
+    ...trainedModelCommands({
+        resource: "ml-task",
+        ids: "ANALYSIS_ID TASK_ID MODEL_ID",
+        noun: "lab model",
+        model: (c, a, pk) => c.mlTasks.model(a[0], a[1], a[2], pk),
+        downloadDocumentation: (c, exportId, pk) => c.mlTasks.downloadModelDocumentation(exportId, pk),
+    }),
 });

package/dist/src/cli/commands/mlflow.d.ts

@@ -0,0 +1,11 @@
+import type { MlflowDeployRunOptions, MlflowExperimentsDatasetOptions, MlflowInferenceInfo } from "../../resources/mlflow-extension.js";
+import type { CommandMeta } from "../types.js";
+type Flags = Record<string, string | boolean>;
+/** `dss mlflow set-inference-info` flags → SDK inference info (shared with --plan). */
+export declare function inferenceInfoFromFlags(runId: string, f: Flags): MlflowInferenceInfo;
+/** `dss mlflow deploy-run` flags → SDK deploy options (shared with --plan). */
+export declare function deployRunOptionsFromFlags(runId: string, savedModelId: string, f: Flags): MlflowDeployRunOptions;
+/** `dss mlflow create-experiments-dataset` flags → SDK options (shared with --plan). */
+export declare function experimentsDatasetOptionsFromFlags(datasetName: string, f: Flags): MlflowExperimentsDatasetOptions;
+export declare const mlflowCommands: Record<string, CommandMeta>;
+export {};

package/dist/src/cli/commands/mlflow.js

@@ -0,0 +1,121 @@
+import { num, parseBooleanOption, splitCsvFlag, } from "../coerce.js";
+import { executionMode, } from "../flags.js";
+import { withUsage, } from "../syntax.js";
+import { UsageError, } from "../usage.js";
+/** `dss mlflow set-inference-info` flags → SDK inference info (shared with --plan). */
+export function inferenceInfoFromFlags(runId, f) {
+    const predictionType = f["prediction-type"];
+    if (typeof predictionType !== "string") {
+        throw new UsageError("--prediction-type is required.", "missing_required_flag");
+    }
+    const classes = splitCsvFlag(f["classes"]);
+    return {
+        runId,
+        predictionType: predictionType.toUpperCase(),
+        ...(classes.length > 0 ? { classes, } : {}),
+        ...(typeof f["code-env"] === "string" ? { codeEnvName: f["code-env"], } : {}),
+        ...(typeof f["target"] === "string" ? { target: f["target"], } : {}),
+    };
+}
+/** `dss mlflow deploy-run` flags → SDK deploy options (shared with --plan). */
+export function deployRunOptionsFromFlags(runId, savedModelId, f) {
+    const classLabels = splitCsvFlag(f["classes"]);
+    const setActive = f["set-active"];
+    const threshold = f["binary-classification-threshold"];
+    const optimal = f["use-optimal-threshold"];
+    const skipReports = f["skip-expensive-reports"];
+    return {
+        runId,
+        savedModelId,
+        ...(typeof f["version-id"] === "string" ? { versionId: f["version-id"], } : {}),
+        ...(typeof f["model-name"] === "string" ? { modelName: f["model-name"], } : {}),
+        ...(typeof f["evaluation-dataset"] === "string"
+            ? { evaluationDataset: f["evaluation-dataset"], }
+            : {}),
+        ...(typeof f["target"] === "string" ? { targetColumnName: f["target"], } : {}),
+        ...(classLabels.length > 0 ? { classLabels, } : {}),
+        ...(typeof f["code-env"] === "string" ? { codeEnvName: f["code-env"], } : {}),
+        ...(setActive !== undefined ? { activate: parseBooleanOption(setActive, "--set-active"), } : {}),
+        ...(threshold !== undefined
+            ? { binaryClassificationThreshold: num(threshold, "--binary-classification-threshold"), }
+            : {}),
+        ...(optimal !== undefined
+            ? { useOptimalThreshold: parseBooleanOption(optimal, "--use-optimal-threshold"), }
+            : {}),
+        ...(skipReports !== undefined
+            ? { skipExpensiveReports: parseBooleanOption(skipReports, "--skip-expensive-reports"), }
+            : {}),
+    };
+}
+/** `dss mlflow create-experiments-dataset` flags → SDK options (shared with --plan). */
+export function experimentsDatasetOptionsFromFlags(datasetName, f) {
+    const experimentIds = splitCsvFlag(f["experiments"]);
+    const viewType = f["view-type"];
+    const format = f["format"];
+    return {
+        datasetName,
+        ...(experimentIds.length > 0 ? { experimentIds, } : {}),
+        ...(typeof viewType === "string"
+            ? {
+                viewType: viewType.toUpperCase(),
+            }
+            : {}),
+        ...(typeof f["filter"] === "string" ? { filter: f["filter"], } : {}),
+        ...(typeof format === "string"
+            ? { format: format.toUpperCase(), }
+            : {}),
+    };
+}
+export const mlflowCommands = withUsage("mlflow", {
+    "list-models": {
+        handler: (c, a, f) => c.mlflowExtension.listModels(a[0], f["project-key"]),
+        description: "List the models an MLflow experiment-tracking run logged ({runId, artifactPath}).",
+        examples: ["dss mlflow list-models RUN_ID",],
+    },
+    "set-inference-info": {
+        handler: async (c, a, f) => {
+            await c.mlflowExtension.setRunInferenceInfo(inferenceInfoFromFlags(a[0], f), f["project-key"]);
+            return { updated: a[0], resource: "mlflow", };
+        },
+        description: "Record an MLflow run's prediction type, classes, code env, and target so deploy-run can use them.",
+        examples: [
+            "dss mlflow set-inference-info RUN_ID --prediction-type MULTICLASS --classes a,b,c --target species",
+        ],
+    },
+    "deploy-run": {
+        handler: (c, a, f) => c.mlflowExtension.deployRun(deployRunOptionsFromFlags(a[0], a[1], f), f["project-key"]),
+        description: "Deploy an MLflow run's model as a version of an existing saved model (default version id: timestamp); --evaluation-dataset evaluates it. Synchronous: DSS loads the model in its code env, often past 30 s, so raise --request-timeout.",
+        examples: [
+            "dss mlflow deploy-run RUN_ID SAVED_MODEL_ID --version-id v2 --code-env py311_mlflow --request-timeout 300000",
+        ],
+    },
+    "create-experiments-dataset": {
+        handler: async (c, a, f) => {
+            await c.mlflowExtension.createExperimentsDataset(experimentsDatasetOptionsFromFlags(a[0], f), f["project-key"]);
+            return { created: a[0], resource: "mlflow", };
+        },
+        description: "Create a virtual dataset exposing the project's MLflow experiment-tracking runs.",
+        examples: ["dss mlflow create-experiments-dataset mlflow_runs --experiments FGXlefMU",],
+    },
+    "garbage-collect": {
+        handler: async (c, _a, f) => {
+            if (executionMode(f).dryRun) {
+                return { dryRun: true, action: "garbage-collect", resource: "mlflow", };
+            }
+            await c.mlflowExtension.garbageCollect(f["project-key"]);
+            return { garbageCollected: true, resource: "mlflow", };
+        },
+        description: "Permanently delete the project's MLflow experiments and runs marked as deleted.",
+        examples: ["dss mlflow garbage-collect --dry-run",],
+    },
+    "clean-db": {
+        handler: async (c, _a, f) => {
+            if (executionMode(f).dryRun)
+                return { dryRun: true, action: "clean-db", resource: "mlflow", };
+            await c.mlflowExtension.cleanDb(f["project-key"]);
+            return { cleaned: true, resource: "mlflow", };
+        },
+        description: "Admin: delete ALL MLflow experiment-tracking data of the project (experiments, runs, params, metrics, tags). Irreversible.",
+        examples: ["dss mlflow clean-db --plan",],
+    },
+});

package/dist/src/cli/commands/plugin.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import { validatedPluginGitUrl, validatePluginDestinationPath, validatePluginId, validatePluginName, validatePluginPath, } from "../../resources/plugins.js";
-import { num, readStdinText, } from "../coerce.js";
+import { writeResponseToFile, } from "../../utils/response-file.js";
+import { num, readStdinText, sha256Hex, } from "../coerce.js";
 import { executionMode, } from "../flags.js";
 import { planResult, } from "../output.js";
 import { commandUsage, withUsage, } from "../syntax.js";
@@ -188,7 +189,7 @@ export const pluginCommands = withUsage("plugin", {
             }
             const pluginId = validatePluginId(a[0]);
             const res = await c.plugins.download(pluginId);
-            const bytes = await writeResponseToFileForPlugin(out, res);
+            const bytes = await writeResponseToFile(out, res);
             return { path: out, bytes, };
         },
         description: "Download a development plugin as a zip archive to a local file.",
@@ -598,7 +599,7 @@ export const pluginCommands = withUsage("plugin", {
             const out = f["output"];
             if (typeof out === "string" && out.trim() !== "") {
                 const res = await c.plugins.downloadFile(pluginId, path);
-                const bytes = await writeResponseToFileForPlugin(out, res);
+                const bytes = await writeResponseToFile(out, res);
                 return { path: out, bytes, };
             }
             return { data: await c.plugins.getFile(pluginId, path), };
@@ -634,10 +635,7 @@ export const pluginCommands = withUsage("plugin", {
                     : await readStdinText();
             await c.plugins.putFile(pluginId, path, content);
             const bytes = typeof content === "string" ? Buffer.byteLength(content, "utf8") : content.length;
-            const hasher = new Bun.CryptoHasher("sha256");
-            hasher.update(typeof content === "string" ? content : new Uint8Array(content));
-            const sha256 = hasher.digest("hex");
-            return { written: path, pluginId, bytes, sha256, };
+            return { written: path, pluginId, bytes, sha256: sha256Hex(content), };
         },
         description: "Create or replace a development plugin file with text or binary content; reports the written byte count and sha256.",
         examples: [
@@ -760,7 +758,3 @@ function readSettingsInput(flags) {
     }
     return parsed;
 }
-async function writeResponseToFileForPlugin(path, res) {
-    const { writeResponseToFile, } = await import("../../utils/response-file.js");
-    return writeResponseToFile(path, res);
-}

package/dist/src/cli/commands/project-deployer.js

@@ -103,4 +103,74 @@ export const projectDeployerCommands = withUsage("project-deployer", {
         description: "Create a Project Deployer infrastructure.",
         examples: ["dss project-deployer create-infra --data-file infra.json",],
     },
+    "list-stages": {
+        handler: (c) => c.projectDeployer.listStages(),
+        description: "List the Project Deployer stages (e.g. Development, Test, Production).",
+        examples: ["dss project-deployer list-stages",],
+    },
+    "get-infra": {
+        handler: (c, a) => c.projectDeployer.getInfra(a[0]),
+        description: "Get a Project Deployer infrastructure (stage, automation node, deployments).",
+        examples: ["dss project-deployer get-infra prod-infra",],
+    },
+    "infra-settings": {
+        handler: (c, a) => c.projectDeployer.getInfraSettings(a[0]),
+        description: "Get an infrastructure's settings (permissions, automation node URL, connection remappings).",
+        examples: ["dss project-deployer infra-settings prod-infra",],
+    },
+    "save-infra-settings": {
+        handler: async (c, a, f) => {
+            await c.projectDeployer.saveInfraSettings(a[0], requiredJsonInput(f, "--data, --data-file, or --stdin is required (settings from infra-settings)."));
+            return { updated: a[0], resource: "project-deployer", };
+        },
+        description: "Save infrastructure settings obtained from infra-settings, edited.",
+        examples: ["dss project-deployer save-infra-settings prod-infra --data-file infra.json",],
+    },
+    "delete-infra": {
+        handler: async (c, a) => {
+            await c.projectDeployer.deleteInfra(a[0]);
+            return { deleted: a[0], resource: "project-deployer", };
+        },
+        description: "Delete an infrastructure that no deployment uses.",
+        examples: ["dss project-deployer delete-infra old-infra --plan",],
+    },
+    "deployment-settings": {
+        handler: (c, a) => c.projectDeployer.getDeploymentSettings(a[0]),
+        description: "Get a deployment's settings (infra, bundle, remappings); edit and send to save-deployment-settings.",
+        examples: ["dss project-deployer deployment-settings v1-on-prod",],
+    },
+    "governance-status": {
+        handler: (c, a, f) => c.projectDeployer.getGovernanceStatus(a[0], f["bundle-id"]),
+        description: "Governance status of a deployment's bundle (or --bundle-id): messages on whether it may be deployed.",
+        examples: ["dss project-deployer governance-status v1-on-prod",],
+    },
+    "delete-project": {
+        handler: async (c, a) => {
+            await c.projectDeployer.deleteProject(a[0]);
+            return { deleted: a[0], resource: "project-deployer", };
+        },
+        description: "Delete a published project that no deployment uses.",
+        examples: ["dss project-deployer delete-project MYPROJECT --plan",],
+    },
+    "project-settings": {
+        handler: (c, a) => c.projectDeployer.getProjectSettings(a[0]),
+        description: "Get a published project's settings (owner, permissions).",
+        examples: ["dss project-deployer project-settings MYPROJECT",],
+    },
+    "save-project-settings": {
+        handler: async (c, a, f) => {
+            await c.projectDeployer.saveProjectSettings(a[0], requiredJsonInput(f, "--data, --data-file, or --stdin is required (settings from project-settings)."));
+            return { updated: a[0], resource: "project-deployer", };
+        },
+        description: "Save published project settings obtained from project-settings, edited.",
+        examples: ["dss project-deployer save-project-settings MYPROJECT --data-file published.json",],
+    },
+    "delete-bundle": {
+        handler: async (c, a) => {
+            await c.projectDeployer.deleteBundle(a[0], a[1]);
+            return { deleted: a[1], resource: "project-deployer", project: a[0], };
+        },
+        description: "Delete a bundle of a published project that no deployment uses.",
+        examples: ["dss project-deployer delete-bundle MYPROJECT v1 --plan",],
+    },
 });

package/dist/src/cli/commands/project-library.js

@@ -8,9 +8,6 @@ import { commandUsage, withUsage, } from "../syntax.js";
 import { requireArgs, UsageError, } from "../usage.js";
 const PROJECT_LIBRARY_EXIT_CODES = { usage: 1, error: 2, transient: 3, };
 const PUT_FLAG_ERROR_HINT = "Pass a 64-character SHA-256 hex digest (lowercase or uppercase).";
-function sha256BytesHex(bytes) {
-    return new Bun.CryptoHasher("sha256").update(bytes).digest("hex");
-}
 function projectLibraryContentsEndpoint(client, projectKey, path) {
     return encodedProjectEndpoint(client, projectKey, `/libraries/contents/${encodeLibraryPath(path)}`);
 }
@@ -43,7 +40,7 @@ export function projectLibraryPutPayload(flags) {
             contentSource: "file",
             file: flags["file"],
             bytes: bytes.length,
-            sha256: sha256BytesHex(bytes),
+            sha256: sha256Hex(bytes),
             ...(expectSha256 ? { expectSha256, } : {}),
         };
     }
@@ -90,7 +87,7 @@ export const projectLibraryCommands = withUsage("project-library", {
                 throw new UsageError("--output PATH is required.", "missing_required_flag");
             const bytes = await c.projectLibrary.getFileBytes(a[0], f["project-key"]);
             const written = await Bun.write(out, bytes, { createPath: false, });
-            return { path: out, bytes: written, sha256: sha256BytesHex(bytes), };
+            return { path: out, bytes: written, sha256: sha256Hex(bytes), };
         },
         description: "Download a project library file's raw bytes to a local file.",
         examples: ["dss project-library get-bytes static/logo.png --output ./logo.png",],

package/dist/src/cli/commands/project.js

@@ -278,4 +278,12 @@ export const projectCommands = withUsage("project", {
         description: "Update a project's settings via JSON merge.",
         examples: ["dss project settings-set --data-file settings.json --project-key MY_PROJ",],
     },
+    "push-to-git-remote": {
+        handler: async (c, a, f) => {
+            await c.projects.pushToGitRemote(a[0], f["project-key"]);
+            return { pushed: a[0], resource: "project", };
+        },
+        description: "Push the project to a Git remote already declared in DSS (per-project Git mode). Branches, commits, pulls, and remotes: dss project-git.",
+        examples: ["dss project push-to-git-remote origin --plan",],
+    },
 });

package/dist/src/cli/commands/recipe.d.ts

@@ -1,4 +1,7 @@
+import { recipeCreateWarnings } from "../../resources/recipe-create.js";
 import type { CommandMeta } from "../types.js";
+/** Queue the stderr warnings for `recipe create` options (also used by `--plan` and `--dry-run`). */
+export declare function enqueueRecipeCreateWarnings(options: Parameters<typeof recipeCreateWarnings>[0]): void;
 /** Maps `recipe create` flags to SDK options; shared by the handler and `--plan`. */
 export declare function recipeCreateOptionsFromFlags(f: Record<string, string | boolean>): {
     type: string;
@@ -13,6 +16,16 @@ export declare function recipeCreateOptionsFromFlags(f: Record<string, string |
     fuzzyDistance?: string | undefined;
     fuzzyThreshold?: number | undefined;
     fuzzyNormalize: boolean;
+    orderBy?: string | undefined;
+    formula?: string | undefined;
+    filter?: string | undefined;
+    stepOrder?: string[] | undefined;
     projectKey: string | undefined;
+    aggregate?: string[] | undefined;
+    dropColumns?: string[] | undefined;
+    fillEmpty?: string[] | undefined;
+    groupBy?: string[] | undefined;
+    keepColumns?: string[] | undefined;
+    rename?: string[] | undefined;
 };
 export declare const recipeCommands: Record<string, CommandMeta>;