dataiku-sdk 0.10.1 → 0.12.0

package/dist/src/resources/flow-zones.js

@@ -54,8 +54,11 @@ export class FlowZonesResource extends BaseResource {
     async moveItem(zoneId, item, projectKey) {
         return this.moveItems(zoneId, [item,], projectKey);
     }
-    /** Get the graph for a single flow zone. */
+    /** Get the full flow graph, or the graph for a single non-default flow zone. */
     async graph(zoneId, projectKey) {
+        if (zoneId === undefined || zoneId === "default") {
+            return this.client.get(`/public/api/projects/${this.enc(projectKey)}/flow/graph/`);
+        }
         return this.client.get(`/public/api/projects/${this.enc(projectKey)}/flow/zones/${encodeURIComponent(zoneId)}/graph`);
     }
 }

package/dist/src/resources/meanings.d.ts

@@ -37,5 +37,7 @@ export declare class MeaningsResource extends BaseResource {
     create(id: string, label: string, type: MeaningType, body?: MeaningCreateBody): Promise<string>;
     /** Replace a user-defined meaning definition. */
     update(meaningId: string, body: MeaningDefinition): Promise<MeaningDefinition>;
+    /** Delete a user-defined meaning definition. */
+    delete(meaningId: string): Promise<void>;
     private meaningPath;
 }

package/dist/src/resources/meanings.js

@@ -27,6 +27,10 @@ export class MeaningsResource extends BaseResource {
     async update(meaningId, body) {
         return this.client.put(this.meaningPath(meaningId), body);
     }
+    /** Delete a user-defined meaning definition. */
+    async delete(meaningId) {
+        await this.client.del(this.meaningPath(meaningId));
+    }
     meaningPath(meaningId) {
         return `/public/api/meanings/${encodeURIComponent(meaningId)}`;
     }

package/dist/src/resources/ml-tasks.d.ts

@@ -0,0 +1,91 @@
+import { BaseResource } from "./base.js";
+export type MlTaskType = "PREDICTION" | "CLUSTERING";
+export interface MlTaskCreateOptions {
+    analysisId: string;
+    taskType: MlTaskType;
+    targetVariable?: string;
+    predictionType?: string;
+    backendType?: string;
+    guessPolicy?: string;
+    projectKey?: string;
+}
+export interface MlTaskCreateResult extends Record<string, unknown> {
+    analysisId?: string;
+    mlTaskId?: string;
+}
+export interface MlTaskFullModelId extends Record<string, unknown> {
+    id?: string;
+    fullModelId?: {
+        sessionId?: string;
+        [key: string]: unknown;
+    };
+}
+export interface MlTaskStatus extends Record<string, unknown> {
+    guessing?: boolean;
+    training?: boolean;
+    fullModelIds?: MlTaskFullModelId[];
+}
+export interface MlTaskSettings extends Record<string, unknown> {
+    taskType?: MlTaskType;
+    predictionType?: string;
+}
+export interface MlTaskActionResult extends Record<string, unknown> {
+    message?: string;
+}
+export interface MlTaskTrainOptions {
+    analysisId: string;
+    mlTaskId: string;
+    sessionName?: string;
+    sessionDescription?: string;
+    runQueue?: boolean;
+    wait?: boolean;
+    projectKey?: string;
+}
+export interface MlTaskTrainingSession extends Record<string, unknown> {
+    sessionId: string;
+}
+export interface MlTaskTrainCompletedResult extends Record<string, unknown> {
+    sessionId: string;
+    trainedModelIds: string[];
+}
+export type MlTaskTrainResult = MlTaskTrainingSession | MlTaskTrainCompletedResult;
+export interface MlTrainedModelDetails extends Record<string, unknown> {
+    id?: string;
+    algorithm?: string;
+    predictionType?: string;
+}
+export interface MlTaskDeployOptions {
+    analysisId: string;
+    mlTaskId: string;
+    modelId: string;
+    trainDatasetRef: string;
+    testDatasetRef?: string;
+    modelName: string;
+    redoOptimization?: boolean;
+    projectKey?: string;
+}
+export interface MlTaskDeployResult extends Record<string, unknown> {
+    savedModelId?: string;
+    trainRecipeName?: string;
+}
+export declare class MlTasksResource extends BaseResource {
+    /** Create a prediction or clustering task in an existing visual analysis. */
+    create(opts: MlTaskCreateOptions): Promise<MlTaskCreateResult>;
+    /** Get the current guessing, training, and trained-model status of a task. */
+    status(analysisId: string, mlTaskId: string, projectKey?: string): Promise<MlTaskStatus>;
+    /** Get the editable settings of an ML task. */
+    getSettings(analysisId: string, mlTaskId: string, projectKey?: string): Promise<MlTaskSettings>;
+    /** Save the full settings object of an ML task. */
+    saveSettings(analysisId: string, mlTaskId: string, settings: MlTaskSettings, projectKey?: string): Promise<MlTaskActionResult | undefined>;
+    /** Start training, optionally waiting for the task to finish. */
+    train(opts: MlTaskTrainOptions): Promise<MlTaskTrainResult>;
+    /** List identifiers for every trained model currently present on the task. */
+    listTrainedModels(analysisId: string, mlTaskId: string, projectKey?: string): Promise<string[]>;
+    /** Get full details for a trained model. */
+    trainedModelDetails(analysisId: string, mlTaskId: string, modelId: string, projectKey?: string): Promise<MlTrainedModelDetails>;
+    /** Deploy a trained model to the Flow as a saved model and training recipe. */
+    deployToFlow(opts: MlTaskDeployOptions): Promise<MlTaskDeployResult>;
+    /** Delete an ML task and its trained models. */
+    delete(analysisId: string, mlTaskId: string, projectKey?: string): Promise<void>;
+    private taskPath;
+}

package/dist/src/resources/ml-tasks.js

@@ -0,0 +1,130 @@
+import { UsageError, } from "../cli/usage.js";
+import { BaseResource, } from "./base.js";
+const TRAIN_POLL_INTERVAL_MS = 5_000;
+function requireNonEmpty(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new UsageError(`${name} must be a non-empty string.`, "validation_failed");
+    }
+    return value;
+}
+function delay(ms) {
+    const { promise, resolve, } = Promise.withResolvers();
+    setTimeout(resolve, ms);
+    return promise;
+}
+function modelIdsFromStatus(status) {
+    if (!Array.isArray(status.fullModelIds))
+        return [];
+    const modelIds = [];
+    for (const model of status.fullModelIds) {
+        if (typeof model?.id === "string" && model.id.length > 0)
+            modelIds.push(model.id);
+    }
+    return modelIds;
+}
+export class MlTasksResource extends BaseResource {
+    /** Create a prediction or clustering task in an existing visual analysis. */
+    async create(opts) {
+        if (opts.taskType !== "PREDICTION" && opts.taskType !== "CLUSTERING") {
+            throw new UsageError("taskType must be PREDICTION or CLUSTERING.", "invalid_enum");
+        }
+        if (opts.taskType === "PREDICTION"
+            && (typeof opts.targetVariable !== "string" || opts.targetVariable.trim().length === 0)) {
+            throw new UsageError("targetVariable is required for PREDICTION ML tasks.", "missing_required_arg");
+        }
+        const analysisId = encodeURIComponent(requireNonEmpty(opts.analysisId, "analysisId"));
+        const backendType = opts.backendType ?? "PY_MEMORY";
+        const guessPolicy = opts.guessPolicy
+            ?? (opts.taskType === "CLUSTERING" ? "KMEANS" : "DEFAULT");
+        requireNonEmpty(backendType, "backendType");
+        requireNonEmpty(guessPolicy, "guessPolicy");
+        if (opts.targetVariable !== undefined)
+            requireNonEmpty(opts.targetVariable, "targetVariable");
+        if (opts.predictionType !== undefined)
+            requireNonEmpty(opts.predictionType, "predictionType");
+        return this.client.post(`/public/api/projects/${this.enc(opts.projectKey)}/lab/${analysisId}/models/`, {
+            taskType: opts.taskType,
+            ...(opts.targetVariable !== undefined
+                ? { targetVariable: opts.targetVariable, }
+                : {}),
+            ...(opts.predictionType !== undefined
+                ? { predictionType: opts.predictionType, }
+                : {}),
+            backendType,
+            guessPolicy,
+        });
+    }
+    /** Get the current guessing, training, and trained-model status of a task. */
+    async status(analysisId, mlTaskId, projectKey) {
+        return this.client.get(`${this.taskPath(analysisId, mlTaskId, projectKey)}/status`);
+    }
+    /** Get the editable settings of an ML task. */
+    async getSettings(analysisId, mlTaskId, projectKey) {
+        return this.client.get(`${this.taskPath(analysisId, mlTaskId, projectKey)}/settings`);
+    }
+    /** Save the full settings object of an ML task. */
+    async saveSettings(analysisId, mlTaskId, settings, projectKey) {
+        if (settings === null || typeof settings !== "object" || Array.isArray(settings)) {
+            throw new UsageError("settings must be an object.", "validation_failed");
+        }
+        return this.client.post(`${this.taskPath(analysisId, mlTaskId, projectKey)}/settings`, settings);
+    }
+    /** Start training, optionally waiting for the task to finish. */
+    async train(opts) {
+        if (opts.sessionName !== undefined)
+            requireNonEmpty(opts.sessionName, "sessionName");
+        if (opts.sessionDescription !== undefined) {
+            requireNonEmpty(opts.sessionDescription, "sessionDescription");
+        }
+        const taskPath = this.taskPath(opts.analysisId, opts.mlTaskId, opts.projectKey);
+        const session = await this.client.post(`${taskPath}/train`, {
+            sessionName: opts.sessionName,
+            sessionDescription: opts.sessionDescription,
+            runQueue: opts.runQueue ?? false,
+        });
+        if (opts.wait !== true)
+            return session;
+        let status = await this.status(opts.analysisId, opts.mlTaskId, opts.projectKey);
+        while (status.training !== false) {
+            await delay(TRAIN_POLL_INTERVAL_MS);
+            status = await this.status(opts.analysisId, opts.mlTaskId, opts.projectKey);
+        }
+        return {
+            sessionId: session.sessionId,
+            trainedModelIds: modelIdsFromStatus(status),
+        };
+    }
+    /** List identifiers for every trained model currently present on the task. */
+    async listTrainedModels(analysisId, mlTaskId, projectKey) {
+        return modelIdsFromStatus(await this.status(analysisId, mlTaskId, projectKey));
+    }
+    /** Get full details for a trained model. */
+    async trainedModelDetails(analysisId, mlTaskId, modelId, projectKey) {
+        const id = encodeURIComponent(requireNonEmpty(modelId, "modelId"));
+        return this.client.get(`${this.taskPath(analysisId, mlTaskId, projectKey)}/models/${id}/details`);
+    }
+    /** Deploy a trained model to the Flow as a saved model and training recipe. */
+    async deployToFlow(opts) {
+        const modelId = encodeURIComponent(requireNonEmpty(opts.modelId, "modelId"));
+        const trainDatasetRef = requireNonEmpty(opts.trainDatasetRef, "trainDatasetRef");
+        const modelName = requireNonEmpty(opts.modelName, "modelName");
+        if (opts.testDatasetRef !== undefined) {
+            requireNonEmpty(opts.testDatasetRef, "testDatasetRef");
+        }
+        return this.client.post(`${this.taskPath(opts.analysisId, opts.mlTaskId, opts.projectKey)}/models/${modelId}/actions/deployToFlow`, {
+            trainDatasetRef,
+            testDatasetRef: opts.testDatasetRef,
+            modelName,
+            redoOptimization: opts.redoOptimization ?? true,
+        });
+    }
+    /** Delete an ML task and its trained models. */
+    async delete(analysisId, mlTaskId, projectKey) {
+        await this.client.del(`${this.taskPath(analysisId, mlTaskId, projectKey)}/`);
+    }
+    taskPath(analysisId, mlTaskId, projectKey) {
+        const analysis = encodeURIComponent(requireNonEmpty(analysisId, "analysisId"));
+        const task = encodeURIComponent(requireNonEmpty(mlTaskId, "mlTaskId"));
+        return `/public/api/projects/${this.enc(projectKey)}/models/lab/${analysis}/${task}`;
+    }
+}

package/dist/src/resources/model-evaluation-stores.d.ts

@@ -0,0 +1,41 @@
+import { BaseResource } from "./base.js";
+export interface ModelEvaluationStoreListItem extends Record<string, unknown> {
+    id?: string;
+    name?: string;
+    projectKey?: string;
+    mesFlavor?: string;
+}
+export interface ModelEvaluationStore extends Record<string, unknown> {
+    id?: string;
+    name?: string;
+    projectKey?: string;
+    mesFlavor?: string;
+}
+export interface ModelEvaluationStoreCreateOptions {
+    name: string;
+    projectKey?: string;
+}
+export interface ModelEvaluationStoreCreateResult extends Record<string, unknown> {
+    id?: string;
+    name?: string;
+    projectKey?: string;
+}
+export interface ModelEvaluationListItem extends Record<string, unknown> {
+    id?: string;
+    evaluationId?: string;
+    createdOn?: number;
+    label?: string;
+}
+export declare class ModelEvaluationStoresResource extends BaseResource {
+    /** List model evaluation stores in a project. */
+    list(projectKey?: string): Promise<ModelEvaluationStoreListItem[]>;
+    /** Get model evaluation store settings and metadata. */
+    get(modelEvaluationStoreId: string, projectKey?: string): Promise<ModelEvaluationStore>;
+    /** Create a tabular model evaluation store. */
+    create(opts: ModelEvaluationStoreCreateOptions): Promise<ModelEvaluationStoreCreateResult>;
+    /** List evaluations in a model evaluation store. */
+    listEvaluations(modelEvaluationStoreId: string, projectKey?: string): Promise<ModelEvaluationListItem[]>;
+    /** Delete a model evaluation store and its evaluations. */
+    delete(modelEvaluationStoreId: string, projectKey?: string): Promise<void>;
+    private storePath;
+}

package/dist/src/resources/model-evaluation-stores.js

@@ -0,0 +1,36 @@
+import { UsageError, } from "../cli/usage.js";
+import { BaseResource, } from "./base.js";
+function requireNonEmpty(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new UsageError(`${name} must be a non-empty string.`, "validation_failed");
+    }
+    return value;
+}
+export class ModelEvaluationStoresResource extends BaseResource {
+    /** List model evaluation stores in a project. */
+    async list(projectKey) {
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/evaluationstores/`);
+    }
+    /** Get model evaluation store settings and metadata. */
+    async get(modelEvaluationStoreId, projectKey) {
+        return this.client.get(this.storePath(modelEvaluationStoreId, projectKey));
+    }
+    /** Create a tabular model evaluation store. */
+    async create(opts) {
+        const name = requireNonEmpty(opts.name, "name");
+        const projectKey = this.resolveProjectKey(opts.projectKey);
+        return this.client.post(`/public/api/projects/${encodeURIComponent(projectKey)}/evaluationstores/?flavor=TABULAR`, { projectKey, name, });
+    }
+    /** List evaluations in a model evaluation store. */
+    async listEvaluations(modelEvaluationStoreId, projectKey) {
+        return this.client.get(`${this.storePath(modelEvaluationStoreId, projectKey)}/evaluations/`);
+    }
+    /** Delete a model evaluation store and its evaluations. */
+    async delete(modelEvaluationStoreId, projectKey) {
+        await this.client.del(this.storePath(modelEvaluationStoreId, projectKey));
+    }
+    storePath(modelEvaluationStoreId, projectKey) {
+        const id = encodeURIComponent(requireNonEmpty(modelEvaluationStoreId, "modelEvaluationStoreId"));
+        return `/public/api/projects/${this.enc(projectKey)}/evaluationstores/${id}`;
+    }
+}

package/dist/src/resources/notebooks.d.ts

@@ -5,15 +5,11 @@ export declare class NotebooksResource extends BaseResource {
     listJupyter(projectKey?: string): Promise<JupyterNotebookSummary[]>;
     /** Get the full content of a Jupyter notebook. */
     getJupyter(name: string, projectKey?: string): Promise<JupyterNotebookContent>;
+    /** Create a Jupyter notebook. */
+    createJupyter(name: string, content: JupyterNotebookContent, projectKey?: string): Promise<void>;
     /** Save (overwrite) a Jupyter notebook's content. */
     saveJupyter(name: string, content: JupyterNotebookContent, projectKey?: string): Promise<void>;
-    /**
-     * Delete a Jupyter notebook.
-     *
-     * The SDK intentionally does not expose notebook creation as a first-class
-     * resource method yet; integration tests create disposable notebooks through
-     * the documented project-level create endpoint.
-     */
+    /** Delete a Jupyter notebook. */
     deleteJupyter(name: string, projectKey?: string): Promise<void>;
     /**
      * Clear all cell outputs from a Jupyter notebook.
@@ -36,6 +32,8 @@ export declare class NotebooksResource extends BaseResource {
     listSql(projectKey?: string): Promise<SqlNotebookSummary[]>;
     /** Get the full content of a SQL notebook. */
     getSql(id: string, projectKey?: string): Promise<SqlNotebookContent>;
+    /** Create a SQL notebook. */
+    createSql(id: string, content: SqlNotebookContent, projectKey?: string): Promise<void>;
     /** Save (overwrite) a SQL notebook's content. */
     saveSql(id: string, content: SqlNotebookContent, projectKey?: string): Promise<void>;
     /** Delete a SQL notebook. */

package/dist/src/resources/notebooks.js

@@ -13,18 +13,17 @@ export class NotebooksResource extends BaseResource {
         const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/jupyter-notebooks/${nameEnc}`);
         return this.client.safeParse(JupyterNotebookContentSchema, raw, "notebooks.getJupyter");
     }
+    /** Create a Jupyter notebook. */
+    async createJupyter(name, content, projectKey) {
+        const nameEnc = encodeURIComponent(name);
+        await this.client.post(`/public/api/projects/${this.enc(projectKey)}/jupyter-notebooks/${nameEnc}`, content);
+    }
     /** Save (overwrite) a Jupyter notebook's content. */
     async saveJupyter(name, content, projectKey) {
         const nameEnc = encodeURIComponent(name);
         await this.client.putVoid(`/public/api/projects/${this.enc(projectKey)}/jupyter-notebooks/${nameEnc}`, content);
     }
-    /**
-     * Delete a Jupyter notebook.
-     *
-     * The SDK intentionally does not expose notebook creation as a first-class
-     * resource method yet; integration tests create disposable notebooks through
-     * the documented project-level create endpoint.
-     */
+    /** Delete a Jupyter notebook. */
     async deleteJupyter(name, projectKey) {
         const nameEnc = encodeURIComponent(name);
         await this.client.del(`/public/api/projects/${this.enc(projectKey)}/jupyter-notebooks/${nameEnc}`);
@@ -74,6 +73,10 @@ export class NotebooksResource extends BaseResource {
         const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/sql-notebooks/${idEnc}`);
         return this.client.safeParse(SqlNotebookContentSchema, raw, "notebooks.getSql");
     }
+    /** Create a SQL notebook. */
+    async createSql(id, content, projectKey) {
+        await this.client.post(`/public/api/projects/${this.enc(projectKey)}/sql-notebooks/`, { ...content, id, projectKey: this.resolveProjectKey(projectKey), });
+    }
     /** Save (overwrite) a SQL notebook's content. */
     async saveSql(id, content, projectKey) {
         const idEnc = encodeURIComponent(id);

package/dist/src/resources/projects.d.ts

@@ -69,7 +69,7 @@ export declare class ProjectsResource extends BaseResource {
     private postStream;
     private uploadJson;
     /** Create a new project. */
-    createProject(projectKey: string, name: string, ownerLogin?: string, settings?: ProjectLifecycleSettings | null): Promise<string>;
+    createProject(projectKey: string, name: string, ownerLogin: string, settings?: ProjectLifecycleSettings | null): Promise<Record<string, unknown>>;
     /** Delete a project using the lifecycle endpoint. */
     deleteProject(projectKey: string, dropData?: boolean): Promise<void>;
     /** Duplicate a project. */

package/dist/src/resources/projects.js

@@ -130,10 +130,10 @@ export class ProjectsResource extends BaseResource {
     }
     /** Create a new project. */
     async createProject(projectKey, name, ownerLogin, settings) {
-        return this.client.postText("/public/api/projects/", {
+        return this.client.post("/public/api/projects/", {
             projectKey,
             name,
-            owner: ownerLogin ?? null,
+            owner: ownerLogin,
             settings: settings ?? null,
             description: null,
             permissions: [],

package/dist/src/resources/recipes.d.ts

@@ -103,10 +103,10 @@ export declare class RecipesResource extends BaseResource {
     /** Clone recipe graph/settings and optionally clone a dataset output. */
     clone(sourceName: string, opts: RecipeCloneOptions): Promise<RecipeCloneResult>;
     /**
-    * Download a recipe code payload to a local file.
+        * Download a recipe code payload to a local file.
 
-    * Returns the path to the written file.
-    */
+        * Returns the path to the written file.
+        */
     downloadCode(recipeName: string, opts?: {
         outputPath?: string;
         projectKey?: string;