Refactor job types

Author: naglepuff

client/platform/desktop/backend/native/common.spec.ts

@@ -6,7 +6,7 @@ import { Console } from 'console';
 
 import {
   AnnotationsCurrentVersion, DesktopJob,
-  DesktopJobUpdate, JsonMeta, RunTraining, Settings,
+  DesktopJobUpdate, JobType, JsonMeta, RunTraining, Settings,
 } from 'platform/desktop/constants';
 import { makeEmptyAnnotationFile } from 'platform/desktop/backend/serializers/dive';
 
@@ -695,6 +695,7 @@ describe('native.common', () => {
 
   it('processing good Trained Pipeline folder', async () => {
     const trainingArgs: RunTraining = {
+      type: JobType.RunTraining,
       datasetIds: ['randomID'],
       pipelineName: 'trainedPipelineName',
       trainingConfig: 'trainingConfig',
@@ -715,6 +716,7 @@ describe('native.common', () => {
 
   it('processing bad Trained Pipeline folders', async () => {
     const trainingArgs: RunTraining = {
+      type: JobType.RunTraining,
       datasetIds: ['randomID'],
       pipelineName: 'trainedBadPipelineName',
       trainingConfig: 'trainingConfig',
@@ -730,6 +732,7 @@ describe('native.common', () => {
 
   it('getPipelineList lists pipelines with Trained pipelines', async () => {
     const trainingArgs: RunTraining = {
+      type: JobType.RunTraining,
       datasetIds: ['randomID'],
       pipelineName: 'trainedPipelineName',
       trainingConfig: 'trainingConfig',

client/platform/desktop/backend/native/common.ts

@@ -39,6 +39,7 @@ import {
   RunTraining, ExportDatasetArgs, DesktopMediaImportResponse,
   ExportConfigurationArgs, JobsFolderName, ProjectsFolderName,
   PipelinesFolderName, ConversionArgs,
+  JobType,
 } from 'platform/desktop/constants';
 import {
   cleanString, filterByGlob, makeid, strNumericCompare,
@@ -1187,10 +1188,12 @@ async function finalizeMediaImport(
   if (args.metaFileAbsPath) {
     await dataFileImport(settings, jsonMeta.id, args.metaFileAbsPath);
   }
-  return {
+  const conversionJobArgs: ConversionArgs = {
+    type: JobType.Conversion,
     meta: finalJsonMeta,
     mediaList: srcDstList,
   };
+  return conversionJobArgs;
 }
 
 async function openLink(url: string) {

client/platform/desktop/constants.ts

@@ -152,19 +152,33 @@ export interface NvidiaSmiReply {
   error: string;
 }
 
+export enum JobType {
+  Conversion,
+  ExportTrainedPipeline,
+  RunPipeline,
+  RunTraining,
+}
+
+export interface JobArgs {
+  type: JobType;
+}
+
 /** TODO promote to apispec */
-export interface RunPipeline {
+export interface RunPipeline extends JobArgs {
+  type: JobType.RunPipeline;
   datasetId: string;
   pipeline: Pipe;
 }
 
-export interface ExportTrainedPipeline {
+export interface ExportTrainedPipeline extends JobArgs {
+  type: JobType.ExportTrainedPipeline;
   path: string;
   pipeline: Pipe;
 }
 
 /** TODO promote to apispec */
-export interface RunTraining {
+export interface RunTraining extends JobArgs {
+  type: JobType.RunTraining;
   // datasets to run training on
   datasetIds: string[];
   // new pipeline name to be created
@@ -184,32 +198,13 @@ export interface RunTraining {
   };
 }
 
-export type JobArgs = RunPipeline | RunTraining | ExportTrainedPipeline | ConversionArgs;
-
-export function isRunPipeline(spec: JobArgs): spec is RunPipeline {
-  return 'datasetId' in spec && 'pipeline' in spec;
-}
-
-export function isExportTrainedPipeline(spec: JobArgs): spec is ExportTrainedPipeline {
-  return 'path' in spec && 'pipeline' in spec;
-}
-
-export function isRunTraining(spec: JobArgs): spec is RunTraining {
-  return (
-    'datasetIds' in spec
-    && 'pipelineName' in spec
-    && 'trainingConfig' in spec
-  );
-}
-
-export interface ConversionArgs {
+export interface ConversionArgs extends JobArgs {
+  type: JobType.Conversion;
   meta: JsonMeta;
   mediaList: [string, string][];
 }
 
-export function isConversion(spec: JobArgs): spec is ConversionArgs {
-  return 'meta' in spec && 'mediaList' in spec;
-}
+export type Job = ConversionArgs | RunPipeline | RunTraining | ExportTrainedPipeline;
 
 export interface DesktopJob {
   // key unique identifier for this job

client/platform/desktop/frontend/api.ts

@@ -19,7 +19,7 @@ import {
 import {
   DesktopMetadata, NvidiaSmiReply,
   RunPipeline, RunTraining, ExportTrainedPipeline, ExportDatasetArgs, ExportConfigurationArgs,
-  DesktopMediaImportResponse, ConversionArgs,
+  DesktopMediaImportResponse, ConversionArgs, JobType,
 } from 'platform/desktop/constants';
 
 import { gpuJobQueue, cpuJobQueue } from './store/jobs';
@@ -92,6 +92,7 @@ async function getTrainingConfigurations(): Promise<TrainingConfigs> {
 
 async function runPipeline(itemId: string, pipeline: Pipe): Promise<void> {
   const args: RunPipeline = {
+    type: JobType.RunPipeline,
     pipeline,
     datasetId: itemId,
   };
@@ -100,6 +101,7 @@ async function runPipeline(itemId: string, pipeline: Pipe): Promise<void> {
 
 async function exportTrainedPipeline(path: string, pipeline: Pipe): Promise<void> {
   const args: ExportTrainedPipeline = {
+    type: JobType.ExportTrainedPipeline,
     path,
     pipeline,
   };
@@ -120,6 +122,7 @@ async function runTraining(
   },
 ): Promise<void> {
   const args: RunTraining = {
+    type: JobType.RunTraining,
     datasetIds: folderIds,
     pipelineName,
     trainingConfig: config,

client/platform/desktop/frontend/components/JobsQueued.vue

@@ -1,10 +1,7 @@
 <script lang="ts">
 import {
-  isConversion,
-  isExportTrainedPipeline,
-  isRunPipeline,
-  isRunTraining,
-  JobArgs,
+  Job,
+  JobType,
 } from 'platform/desktop/constants';
 import {
   defineComponent,
@@ -21,25 +18,25 @@ import { datasets } from '../store/dataset';
 
 export default defineComponent({
   setup() {
-    const queuedJobSpecs: Ref<JobArgs[]> = ref([]);
+    const queuedJobSpecs: Ref<Job[]> = ref([]);
     function updateQueuedJobSpecs() {
       queuedJobSpecs.value = [];
-      queuedGpuJobs.value.forEach((spec: JobArgs) => queuedJobSpecs.value.push(spec));
-      queuedCpuJobs.value.forEach((spec: JobArgs) => queuedJobSpecs.value.push(spec));
+      queuedGpuJobs.value.forEach((spec: Job) => queuedJobSpecs.value.push(spec));
+      queuedCpuJobs.value.forEach((spec: Job) => queuedJobSpecs.value.push(spec));
     }
     watch([() => queuedCpuJobs, () => queuedGpuJobs], updateQueuedJobSpecs, { deep: true });
 
-    function getQueuedJobTitle(jobSpec: JobArgs): string {
-      if (isConversion(jobSpec)) {
+    function getQueuedJobTitle(jobSpec: Job): string {
+      if (jobSpec.type === JobType.Conversion) {
         return `conversion: ${datasets.value[jobSpec.meta.id]?.name || jobSpec.meta.id}`;
       }
-      if (isRunPipeline(jobSpec)) {
+      if (jobSpec.type === JobType.RunPipeline) {
         return `pipeline: ${datasets.value[jobSpec.datasetId]?.name || jobSpec.datasetId}`;
       }
-      if (isExportTrainedPipeline(jobSpec)) {
+      if (jobSpec.type === JobType.ExportTrainedPipeline) {
         return `export trained pipeline: ${jobSpec.path}`;
       }
-      if (isRunTraining(jobSpec)) {
+      if (jobSpec.type === JobType.RunTraining) {
         const title = `training: ${datasets.value[jobSpec.datasetIds[0]]?.name || jobSpec.datasetIds[0]}`;
         if (jobSpec.datasetIds.length > 1) {
           return `${title} (and ${jobSpec.datasetIds.length - 1} more)`;
@@ -49,14 +46,14 @@ export default defineComponent({
       return 'queued job';
     }
 
-    function getJobDatasets(jobSpec: JobArgs): string[] {
-      if (isConversion(jobSpec)) {
+    function getJobDatasets(jobSpec: Job): string[] {
+      if (jobSpec.type === JobType.Conversion) {
         return [jobSpec.meta.id];
       }
-      if (isRunPipeline(jobSpec)) {
+      if (jobSpec.type === JobType.RunPipeline) {
         return [jobSpec.datasetId];
       }
-      if (isRunTraining(jobSpec)) {
+      if (jobSpec.type === JobType.RunTraining) {
         return jobSpec.datasetIds;
       }
       return [];
@@ -67,12 +64,11 @@ export default defineComponent({
     });
 
     return {
+      JobType,
       queuedJobSpecs,
       datasets,
       getQueuedJobTitle,
       getJobDatasets,
-      isRunPipeline,
-      isExportTrainedPipeline,
     };
   },
 });
@@ -98,7 +94,7 @@ export default defineComponent({
             </v-card-title>
             <v-card-text>
               <table class="key-value-table">
-                <tr v-if="isRunPipeline(jobSpec) || isExportTrainedPipeline(jobSpec)">
+                <tr v-if="jobSpec.type === JobType.RunPipeline || jobSpec.type === JobType.ExportTrainedPipeline">
                   <td>Pipe</td>
                   <td>{{ jobSpec.pipeline.name }}</td>
                 </tr>

client/platform/desktop/frontend/components/Recent.vue

@@ -7,7 +7,7 @@ import {
 
 import type { DatasetType, MultiCamImportArgs } from 'dive-common/apispec';
 import { itemsPerPageOptions } from 'dive-common/constants';
-import { isConversion, DesktopMediaImportResponse, JobArgs } from 'platform/desktop/constants';
+import { JobType, DesktopMediaImportResponse, Job } from 'platform/desktop/constants';
 
 import TooltipBtn from 'vue-media-annotator/components/TooltipButton.vue';
 
@@ -124,8 +124,8 @@ export default defineComponent({
     const queuedConversionDatasetIds = ref([] as string[]);
     watch(recentHistory, () => {
       queuedConversionDatasetIds.value = [];
-      cpuJobQueue.jobSpecs.forEach((spec: JobArgs) => {
-        if (isConversion(spec)) {
+      cpuJobQueue.jobSpecs.forEach((spec: Job) => {
+        if (spec.type === JobType.Conversion) {
           queuedConversionDatasetIds.value.push(spec.meta.id);
         }
       });

client/platform/desktop/frontend/store/queues/asyncCpuJobQueue.ts

@@ -1,18 +1,17 @@
 import {
+  JobType,
   ConversionArgs,
   ExportTrainedPipeline,
-  isConversion,
-  isExportTrainedPipeline,
   DesktopJob,
 } from 'platform/desktop/constants';
 import AsyncJobQueue from './asyncJobQueue';
 
 export default class AsyncCpuJobQueue extends AsyncJobQueue<ConversionArgs | ExportTrainedPipeline> {
   async beginJob(spec: ConversionArgs | ExportTrainedPipeline) {
     let newJob: DesktopJob;
-    if (isConversion(spec)) {
+    if (spec.type === JobType.Conversion) {
       newJob = await this.ipcRenderer.invoke('convert', spec);
-    } else if (isExportTrainedPipeline(spec)) {
+    } else if (spec.type === JobType.ExportTrainedPipeline) {
       newJob = await this.ipcRenderer.invoke('export-trained-pipeline', spec);
     } else {
       throw new Error('CPU job type not able to be queued');

client/platform/desktop/frontend/store/queues/asyncGpuJobQueue.ts

@@ -1,18 +1,17 @@
 import {
+  JobType,
   RunPipeline,
   RunTraining,
-  isRunPipeline,
-  isRunTraining,
   DesktopJob,
 } from 'platform/desktop/constants';
 import AsyncJobQueue from './asyncJobQueue';
 
 export default class AsyncGpuJobQueue extends AsyncJobQueue<RunPipeline | RunTraining> {
   async beginJob(spec: RunPipeline | RunTraining) {
     let newJob: DesktopJob;
-    if (isRunPipeline(spec)) {
+    if (spec.type === JobType.RunPipeline) {
       newJob = await this.ipcRenderer.invoke('run-pipeline', spec);
-    } else if (isRunTraining(spec)) {
+    } else if (spec.type === JobType.RunTraining) {
       newJob = await this.ipcRenderer.invoke('run-training', spec);
     } else {
       throw new Error('Unsupported job arguments provided to beginJob.');