Queue experiment from existing

extension/package.json

@@ -197,6 +197,15 @@
           "light": "resources/light/queue-experiment.svg"
         }
       },
+      {
+        "title": "%command.queueExperimentFromExisting%",
+        "command": "dvc.queueExperimentFromExisting",
+        "category": "DVC",
+        "icon": {
+          "dark": "resources/dark/queue-experiment.svg",
+          "light": "resources/light/queue-experiment.svg"
+        }
+      },
       {
         "title": "%command.queueExperiment%",
         "command": "dvc.queueExperiment",
@@ -481,6 +490,10 @@
           "command": "dvc.queueExperimentsFromCsv",
           "when": "dvc.commands.available && dvc.project.available"
         },
+        {
+          "command": "dvc.queueExperimentFromExisting",
+          "when": "dvc.commands.available && dvc.project.available"
+        },
         {
           "command": "dvc.queueExperiment",
           "when": "dvc.commands.available && dvc.project.available"

extension/package.nls.json

@@ -28,6 +28,7 @@
   "command.push": "Push",
   "command.pushTarget": "Push",
   "command.queueExperimentsFromCsv": "Queue Experiments From CSV",
+  "command.queueExperimentFromExisting": "Queue Experiment From Existing",
   "command.queueExperiment": "Queue Experiment",
   "command.removeExperiment": "Remove Experiment",
   "command.removeExperimentsTableFilters": "Remove Filter(s) From Experiments Table",

extension/src/commands/external.ts

@@ -38,6 +38,7 @@ export enum RegisteredCommands {
   EXPERIMENT_SORTS_REMOVE_ALL = 'dvc.views.experimentsSortByTree.removeAllSorts',
   EXPERIMENT_TOGGLE = 'dvc.views.experimentsTree.toggleStatus',
   QUEUE_EXPERIMENTS_FROM_CSV = 'dvc.queueExperimentsFromCsv',
+  QUEUE_EXPERIMENT_FROM_EXISTING = 'dvc.queueExperimentFromExisting',
   STOP_EXPERIMENT = 'dvc.stopRunningExperiment',
 
   PLOTS_SHOW = 'dvc.showPlots',

extension/src/experiments/commands/register.ts

@@ -25,6 +25,14 @@ const registerExperimentCwdCommands = (
         experiments.queueExperimentsFromCsv()
       )
   )
+
+  internalCommands.registerExternalCommand(
+    RegisteredCommands.QUEUE_EXPERIMENT_FROM_EXISTING,
+    () =>
+      experiments.pauseUpdatesThenRun(() =>
+        experiments.queueExperimentFromExisting()
+      )
+  )
 }
 
 const registerExperimentNameCommands = (

extension/src/experiments/index.ts

@@ -1,6 +1,8 @@
 import { Event, EventEmitter, Memento } from 'vscode'
 import { ExperimentsModel } from './model'
 import { pickExperiments } from './model/quickPicks'
+import { pickParamsToQueue } from './model/queue/quickPick'
+import { pickExperimentName } from './quickPick'
 import {
   pickFilterToAdd,
   pickFiltersToRemove
@@ -198,6 +200,22 @@ export class Experiments extends BaseRepository<TableData> {
     }
   }
 
+  public async pickParamsToQueue() {
+    const base = await pickExperimentName(this.experiments.getExperimentNames())
+
+    if (!base) {
+      return
+    }
+
+    const params = this.experiments.getExperimentParams(base)
+
+    if (!params) {
+      return
+    }
+
+    return pickParamsToQueue(params)
+  }
+
   public getExperiments() {
     return this.experiments.getExperiments()
   }

extension/src/experiments/model/index.ts

@@ -10,6 +10,7 @@ import {
 import { collectExperiments } from './collect'
 import { copyOriginalColors } from './colors'
 import { collectColors, Colors } from './colors/collect'
+import { collectFlatExperimentParams } from './queue/collect'
 import { Experiment, RowData } from '../webview/contract'
 import { definedAndNonEmpty, flatten } from '../../util/array'
 import { ExperimentsOutput } from '../../cli/reader'
@@ -167,6 +168,24 @@ export class ExperimentsModel {
     }))
   }
 
+  public getExperimentNames() {
+    return [
+      'workspace',
+      ...this.flattenExperiments().map(experiment => experiment.displayName)
+    ].filter(Boolean) as string[]
+  }
+
+  public getExperimentParams(displayName: string) {
+    const params =
+      displayName === 'workspace'
+        ? this.workspace.params
+        : this.flattenExperiments().find(
+            experiment => experiment.displayName === displayName
+          )?.params
+
+    return collectFlatExperimentParams(params)
+  }
+
   public getSelectable() {
     return this.getExperiments().filter(
       exp => exp.displayName !== 'workspace' && !exp.queued

extension/src/experiments/model/queue/collect.test.ts

@@ -0,0 +1,41 @@
+import { collectFlatExperimentParams } from './collect'
+import rowsFixture from '../../../test/fixtures/expShow/rows'
+import { joinParamOrMetricFilePath } from '../../paramsAndMetrics/paths'
+import { join } from '../../../test/util/path'
+
+describe('collectFlatExperimentParams', () => {
+  it('should flatten the params into an array', () => {
+    const params = collectFlatExperimentParams(rowsFixture[0].params)
+    expect(params).toEqual([
+      { path: joinParamOrMetricFilePath('params.yaml', 'epochs'), value: 2 },
+      {
+        path: joinParamOrMetricFilePath('params.yaml', 'learning_rate'),
+        value: 2.2e-7
+      },
+      {
+        path: joinParamOrMetricFilePath('params.yaml', 'dvc_logs_dir'),
+        value: 'dvc_logs'
+      },
+      {
+        path: joinParamOrMetricFilePath('params.yaml', 'log_file'),
+        value: 'logs.csv'
+      },
+      {
+        path: joinParamOrMetricFilePath('params.yaml', 'dropout'),
+        value: 0.122
+      },
+      {
+        path: joinParamOrMetricFilePath('params.yaml', 'process.threshold'),
+        value: 0.86
+      },
+      {
+        path: joinParamOrMetricFilePath('params.yaml', 'process.test_arg'),
+        value: 'string'
+      },
+      {
+        path: joinParamOrMetricFilePath(join('nested', 'params.yaml'), 'test'),
+        value: true
+      }
+    ])
+  })
+})

extension/src/experiments/model/queue/collect.ts

@@ -0,0 +1,36 @@
+import { Value, ValueTree } from '../../../cli/reader'
+import { joinParamOrMetricFilePath } from '../../paramsAndMetrics/paths'
+import { ParamsOrMetrics } from '../../webview/contract'
+
+export type Param = {
+  path: string
+  value: number | string | boolean
+}
+
+const collectFromParamsFile = (
+  acc: { path: string; value: string | number | boolean }[],
+  key: string | undefined,
+  value: Value | ValueTree,
+  ancestors: string[] = []
+) => {
+  const pathArray = [...ancestors, key].filter(Boolean) as string[]
+
+  if (typeof value === 'object') {
+    Object.entries(value as ValueTree).forEach(([childKey, childValue]) => {
+      return collectFromParamsFile(acc, childKey, childValue, pathArray)
+    })
+    return
+  }
+
+  const path = joinParamOrMetricFilePath(...pathArray)
+
+  acc.push({ path, value })
+}
+
+export const collectFlatExperimentParams = (params: ParamsOrMetrics = {}) => {
+  const acc: { path: string; value: string | number | boolean }[] = []
+  Object.keys(params).forEach(file =>
+    collectFromParamsFile(acc, undefined, params[file], [file])
+  )
+  return acc
+}

extension/src/experiments/queue.ts → extension/src/experiments/model/queue/index.ts

@@ -1,6 +1,6 @@
-import { Flag } from '../cli/args'
-import { readCsv } from '../fileSystem'
-import { definedAndNonEmpty } from '../util/array'
+import { Flag } from '../../../cli/args'
+import { readCsv } from '../../../fileSystem'
+import { definedAndNonEmpty } from '../../../util/array'
 
 const collectParamsToVary = (csvRow: Record<string, unknown>): string[] =>
   Object.entries(csvRow).reduce((acc, [k, v]) => {

extension/src/experiments/model/queue/quickPick.test.ts

@@ -0,0 +1,75 @@
+import { mocked } from 'ts-jest/utils'
+import { pickParamsToQueue } from './quickPick'
+import { getInput } from '../../../vscode/inputBox'
+import { quickPickManyValues } from '../../../vscode/quickPick'
+
+jest.mock('../../../vscode/inputBox')
+jest.mock('../../../vscode/quickPick')
+
+const mockedGetInput = mocked(getInput)
+const mockedQuickPickManyValues = mocked(quickPickManyValues)
+
+beforeEach(() => {
+  jest.resetAllMocks()
+})
+
+describe('pickParamsToQueue', () => {
+  it('should return early if no params are selected', async () => {
+    mockedQuickPickManyValues.mockResolvedValueOnce(undefined)
+
+    const paramsToQueue = await pickParamsToQueue([
+      { path: 'params.yaml:learning_rate', value: 2e-12 }
+    ])
+
+    expect(paramsToQueue).toBeUndefined()
+    expect(mockedGetInput).not.toBeCalled()
+  })
+
+  it('should return early if the user exits from the input box', async () => {
+    const unchanged = { path: 'params.yaml:learning_rate', value: 2e-12 }
+    const initialUserResponse = [
+      { path: 'params.yaml:dropout', value: 0.15 },
+      { path: 'params.yaml:process.threshold', value: 0.86 }
+    ]
+    mockedQuickPickManyValues.mockResolvedValueOnce(initialUserResponse)
+    const firstInput = '0.16'
+    mockedGetInput.mockResolvedValueOnce(firstInput)
+    mockedGetInput.mockResolvedValueOnce(undefined)
+
+    const paramsToQueue = await pickParamsToQueue([
+      unchanged,
+      ...initialUserResponse
+    ])
+
+    expect(paramsToQueue).toBeUndefined()
+    expect(mockedGetInput).toBeCalledTimes(2)
+  })
+
+  it('should convert any selected params into the required format', async () => {
+    const unchanged = { path: 'params.yaml:learning_rate', value: 2e-12 }
+    const initialUserResponse = [
+      { path: 'params.yaml:dropout', value: 0.15 },
+      { path: 'params.yaml:process.threshold', value: 0.86 }
+    ]
+    mockedQuickPickManyValues.mockResolvedValueOnce(initialUserResponse)
+    const firstInput = '0.16'
+    const secondInput = '0.87'
+    mockedGetInput.mockResolvedValueOnce(firstInput)
+    mockedGetInput.mockResolvedValueOnce(secondInput)
+
+    const paramsToQueue = await pickParamsToQueue([
+      unchanged,
+      ...initialUserResponse
+    ])
+
+    expect(paramsToQueue).toEqual([
+      '-S',
+      `params.yaml:dropout=${firstInput}`,
+      '-S',
+      `params.yaml:process.threshold=${secondInput}`,
+      '-S',
+      [unchanged.path, unchanged.value].join('=')
+    ])
+    expect(mockedGetInput).toBeCalledTimes(2)
+  })
+})

extension/src/experiments/model/queue/quickPick.ts

@@ -0,0 +1,63 @@
+import { Param } from './collect'
+import { quickPickManyValues } from '../../../vscode/quickPick'
+import { getInput } from '../../../vscode/inputBox'
+import { Flag } from '../../../cli/args'
+import { definedAndNonEmpty } from '../../../util/array'
+
+const pickParamsToVary = (params: Param[]): Thenable<Param[] | undefined> =>
+  quickPickManyValues<Param>(
+    params.map(param => ({
+      description: `${param.value}`,
+      label: param.path,
+      picked: true,
+      value: param
+    })),
+    { title: 'Select a param to vary' }
+  )
+
+const pickNewParamValues = async (
+  paramsToVary: Param[]
+): Promise<string[] | undefined> => {
+  const args: string[] = []
+  for (const { path, value } of paramsToVary) {
+    const input = await getInput(`Enter a value for ${path}`, `${value}`)
+    if (input === undefined) {
+      return
+    }
+    args.push(Flag.SET_PARAM)
+    args.push([path, input.trim()].join('='))
+  }
+  return args
+}
+
+const addUnchanged = (args: string[], unchanged: Param[]) => {
+  unchanged.forEach(({ path, value }) => {
+    args.push(Flag.SET_PARAM)
+    args.push([path, value].join('='))
+  })
+
+  return args
+}
+
+export const pickParamsToQueue = async (
+  params: Param[]
+): Promise<string[] | undefined> => {
+  const paramsToVary = await pickParamsToVary(params)
+
+  if (!definedAndNonEmpty(paramsToVary)) {
+    return
+  }
+
+  const args = await pickNewParamValues(paramsToVary)
+
+  if (!args) {
+    return
+  }
+
+  const paramPathsToVary = paramsToVary.map(param => param.path)
+  const unchanged = params.filter(
+    param => !paramPathsToVary.includes(param.path)
+  )
+
+  return addUnchanged(args, unchanged)
+}

extension/src/experiments/quickPick.ts

@@ -3,7 +3,7 @@ import { quickPickManyValues, quickPickOne } from '../vscode/quickPick'
 import { reportError } from '../vscode/reporting'
 
 export const pickExperimentName = async (
-  experimentNamesPromise: Promise<string[]>
+  experimentNamesPromise: Promise<string[]> | string[]
 ): Promise<string | undefined> => {
   const experimentNames = await experimentNamesPromise
   if (experimentNames.length === 0) {