feat(protocol-designer): add designerApplication comment to py file a… (#17938)

jerader · web-flow · commit be7d9871caa4 · 2025-04-02T14:52:06.000-04:00
…nd allow reupload

This PR adds the `DESIGNER_APPLICATION` variable which stringifies the
designer application key at the end of a python file. When you export,
the python file now has a long variable at the end with the string.

When you import back into PD, it now accepts the python file and
extracts the stringified blob back into a json.
diff --git a/protocol-designer/src/file-data/__tests__/createFile.test.ts b/protocol-designer/src/file-data/__tests__/createFile.test.ts
@@ -104,17 +104,20 @@ describe('createFile selector', () => {
     // @ts-expect-error(sa, 2021-6-15): resultFunc not part of Selector type
     const result = createPythonFile.resultFunc(
       fileMetadata,
-      OT2_ROBOT_TYPE,
-      entities,
       v7Fixture.initialRobotState,
       v7Fixture.robotStateTimeline,
+      OT2_ROBOT_TYPE,
+      dismissedWarnings,
       ingredLocations,
-      labwareNicknamesById
+      v7Fixture.savedStepForms,
+      v7Fixture.orderedStepIds,
+      labwareNicknamesById,
+      entities
     )
     // This is just a quick smoke test to make sure createPythonFile() produces
     // something that looks like a Python file. The individual sections of the
     // generated Python will be tested in separate unit tests.
-    expect(result).toBe(
+    expect(result.pythonProtocol).toBe(
       `
 from contextlib import nullcontext as pd_step
 from opentrons import protocol_api, types
@@ -166,6 +169,106 @@ def run(protocol: protocol_api.ProtocolContext):
     pass
 `.trimStart()
     )
+
+    expect(result.designerApplication).toEqual({
+      designerApplication: {
+        data: {
+          dismissedWarnings: {
+            form: [],
+            timeline: [],
+          },
+          ingredLocations: {},
+          ingredients: {},
+          labware: {
+            fixedTrash: {
+              displayName: 'Trash',
+              labwareDefURI: 'opentrons/opentrons_1_trash_1100ml_fixed/1',
+            },
+            plateId: {
+              displayName: 'NEST 96 Well Plate 100 µL PCR Full Skirt',
+              labwareDefURI:
+                'opentrons/nest_96_wellplate_100ul_pcr_full_skirt/1',
+            },
+            tiprackId: {
+              displayName: 'Opentrons 96 Tip Rack 10 µL',
+              labwareDefURI: 'opentrons/opentrons_96_tiprack_10ul/1',
+            },
+          },
+          modules: {},
+          orderedStepIds: ['moveLiquidStepId'],
+          pipetteTiprackAssignments: {
+            pipetteId: ['opentrons/opentrons_96_tiprack_10ul/1'],
+          },
+          pipettes: {
+            pipetteId: {
+              pipetteName: 'p10_single',
+            },
+          },
+          savedStepForms: {
+            __INITIAL_DECK_SETUP_STEP__: {
+              id: '__INITIAL_DECK_SETUP_STEP__',
+              labwareLocationUpdate: {
+                fixedTrash: '12',
+                plateId: '1',
+                tiprackId: '2',
+              },
+              moduleLocationUpdate: {},
+              pipetteLocationUpdate: {
+                pipetteId: 'left',
+              },
+              stepType: 'manualIntervention',
+            },
+            moveLiquidStepId: {
+              aspirate_airGap_checkbox: true,
+              aspirate_airGap_volume: '1',
+              aspirate_delay_checkbox: true,
+              aspirate_delay_mmFromBottom: '1',
+              aspirate_delay_seconds: '1',
+              aspirate_flowRate: null,
+              aspirate_labwareId: 'plateId',
+              aspirate_mix_checkbox: false,
+              aspirate_mix_times: null,
+              aspirate_mix_volume: null,
+              aspirate_mmFromBottom: '1',
+              aspirate_touchTip_checkbox: false,
+              aspirate_wellOrder_first: 't2b',
+              aspirate_wellOrder_second: 'l2r',
+              aspirate_wells: ['A1', 'B1'],
+              aspirate_wells_grouped: false,
+              blowout_checkbox: false,
+              blowout_location: 'fixedTrash',
+              changeTip: 'always',
+              dispense_delay_checkbox: false,
+              dispense_delay_mmFromBottom: '0.5',
+              dispense_delay_seconds: '1',
+              dispense_flowRate: null,
+              dispense_labwareId: 'plateId',
+              dispense_mix_checkbox: false,
+              dispense_mix_times: null,
+              dispense_mix_volume: null,
+              dispense_mmFromBottom: '0.5',
+              dispense_touchTip_checkbox: false,
+              dispense_wellOrder_first: 't2b',
+              dispense_wellOrder_second: 'l2r',
+              dispense_wells: ['A12', 'B12'],
+              disposalVolume_checkbox: true,
+              disposalVolume_volume: '1',
+              id: 'moveLiquidStepId',
+              path: 'single',
+              pipetteId: 'pipetteId',
+              preWetTip: false,
+              stepDetails: '',
+              stepName: 'transfer',
+              stepType: 'moveLiquid',
+              volume: '5',
+            },
+          },
+        },
+        version: '8.5.0',
+        name: 'opentrons/protocol-designer',
+      },
+      robot: { model: OT2_ROBOT_TYPE },
+    })
   })
 })
 
diff --git a/protocol-designer/src/file-data/selectors/fileCreator.ts b/protocol-designer/src/file-data/selectors/fileCreator.ts
@@ -52,7 +52,11 @@ import type {
 } from '@opentrons/shared-data'
 import type { LabwareDefByDefURI } from '../../labware-defs'
 import type { Selector } from '../../types'
-import type { PDMetadata } from '../../file-types'
+import type {
+  PDMetadata,
+  PDPythonFile,
+  PythonDesignerApplication,
+} from '../../file-types'
 
 // TODO: BC: 2018-02-21 uncomment this assert, causes test failures
 // console.assert(!isEmpty(process.env.OT_PD_VERSION), 'Could not find application version!')
@@ -305,24 +309,75 @@ export const createFile: Selector<ProtocolFile> = createSelector(
   }
 )
 
-export const createPythonFile: Selector<string> = createSelector(
+export const createPythonFile: Selector<PDPythonFile> = createSelector(
   getFileMetadata,
-  getRobotType,
-  stepFormSelectors.getInvariantContext,
   getInitialRobotState,
   getRobotStateTimeline,
+  getRobotType,
+  dismissSelectors.getAllDismissedWarnings,
   ingredSelectors.getLiquidsByLabwareId,
+  stepFormSelectors.getSavedStepForms,
+  stepFormSelectors.getOrderedStepIds,
   uiLabwareSelectors.getLabwareNicknamesById,
+  stepFormSelectors.getInvariantContext,
   (
     fileMetadata,
-    robotType,
-    invariantContext,
     robotState,
     robotStateTimeline,
-    liquidsByLabwareId,
-    labwareNicknamesById
+    robotType,
+    dismissedWarnings,
+    ingredLocations,
+    savedStepForms,
+    orderedStepIds,
+    labwareNicknamesById,
+    invariantContext
   ) => {
-    return (
+    const {
+      pipetteEntities,
+      moduleEntities,
+      labwareEntities,
+      liquidEntities,
+    } = invariantContext
+
+    const savedOrderedStepIds = orderedStepIds.filter(
+      stepId => savedStepForms[stepId]
+    )
+
+    const ingredients: Ingredients = Object.fromEntries(
+      Object.entries(
+        liquidEntities
+      ).map(([liquidId, { pythonName, ...rest }]) => [liquidId, rest])
+    )
+
+    const designerApplication: PythonDesignerApplication = {
+      robot: {
+        model: robotType,
+      },
+      designerApplication: {
+        name: 'opentrons/protocol-designer',
+        //  hardcoding this version in to avoid unnecessary migrating
+        //  TODO: remember to update to the applicationVersion const
+        version: '8.5.0',
+        data: {
+          pipetteTiprackAssignments: mapValues(
+            pipetteEntities,
+            (
+              p: typeof pipetteEntities[keyof typeof pipetteEntities]
+            ): string[] => p.tiprackDefURI
+          ),
+          dismissedWarnings,
+          ingredients,
+          ingredLocations,
+          savedStepForms,
+          orderedStepIds: savedOrderedStepIds,
+          pipettes: getPipettesLoadInfo(pipetteEntities),
+          modules: getModulesLoadInfo(moduleEntities),
+          labware: getLabwareLoadInfo(labwareEntities, labwareNicknamesById),
+        },
+      },
+    }
+
+    const pythonProtocol =
       [
         // Here are the sections of the Python file:
         pythonImports(),
@@ -332,13 +387,14 @@ export const createPythonFile: Selector<string> = createSelector(
           invariantContext,
           robotState,
           robotStateTimeline,
-          liquidsByLabwareId,
+          ingredLocations,
           labwareNicknamesById,
           robotType
         ),
       ]
         .filter(section => section) // skip any blank sections
         .join('\n\n') + '\n'
-    )
+
+    return { pythonProtocol, designerApplication }
   }
 )
diff --git a/protocol-designer/src/file-types.ts b/protocol-designer/src/file-types.ts
@@ -2,6 +2,7 @@ import type {
   ModuleModel,
   PipetteName,
   ProtocolFile,
+  RobotType,
 } from '@opentrons/shared-data'
 import type { Ingredients } from '@opentrons/step-generation'
 import type { RootState as IngredRoot } from './labware-ingred/reducers'
@@ -34,6 +35,21 @@ export interface PDMetadata {
   labware: Labware
 }
 
+export interface DesignerApplication {
+  designerApplication: { version: string; name: string; data: PDMetadata }
+}
+
+export interface PythonDesignerApplication extends DesignerApplication {
+  robot: {
+    model: RobotType
+  }
+}
+
+export interface PDPythonFile {
+  pythonProtocol: string
+  designerApplication: PythonDesignerApplication
+}
+
 export type PDProtocolFile = ProtocolFile<PDMetadata>
 
 export function getPDMetadata(file: PDProtocolFile): PDMetadata {
diff --git a/protocol-designer/src/load-file/actions.ts b/protocol-designer/src/load-file/actions.ts
@@ -3,7 +3,7 @@ import { selectors as fileDataSelectors } from '../file-data'
 import { saveFile, savePythonFile } from './utils'
 
 import type { SyntheticEvent } from 'react'
-import type { PDProtocolFile } from '../file-types'
+import type { PDProtocolFile, PDPythonFile } from '../file-types'
 import type { GetState, ThunkAction, ThunkDispatch } from '../types'
 import type {
   FileUploadErrorType,
@@ -28,7 +28,9 @@ export const dismissFileUploadMessage = (): DismissFileUploadMessageAction => ({
   type: 'DISMISS_FILE_UPLOAD_MESSAGE',
 })
 // expects valid, parsed JSON protocol.
-export const loadFileAction = (payload: PDProtocolFile): LoadFileAction => ({
+export const loadFileAction = (
+  payload: PDProtocolFile | PDPythonFile
+): LoadFileAction => ({
   type: 'LOAD_FILE',
   payload: migration(payload),
 })
@@ -54,9 +56,9 @@ export const loadProtocolFile = (
   // reset the state of the input to allow file re-uploads
   event.currentTarget.value = ''
 
-  if (!file.name.endsWith('.json')) {
+  if (!file.name.endsWith('.json') && !file.name.endsWith('.py')) {
     fileError('INVALID_FILE_TYPE')
-  } else {
+  } else if (file.name.endsWith('.json')) {
     reader.onload = readEvent => {
       const result = ((readEvent.currentTarget as any) as FileReader).result
       let parsedProtocol: PDProtocolFile | null | undefined
@@ -73,6 +75,31 @@ export const loadProtocolFile = (
       }
     }
 
+    reader.readAsText(file)
+  } else {
+    reader.onload = readEvent => {
+      const result = (readEvent.currentTarget as FileReader).result as string
+
+      try {
+        // Extract designer application blob
+        const designerApplication = result.match(
+          /^DESIGNER_APPLICATION\s?=\s?"""(.*)"""/m
+        )
+        if (designerApplication != null && designerApplication[1]) {
+          const designerApplicationString = designerApplication[1]
+          const designerApplicationJson = JSON.parse(designerApplicationString) // Convert to JSON
+          dispatch(loadFileAction(designerApplicationJson as PDPythonFile))
+        } else {
+          console.warn('No blob found in file.')
+        }
+      } catch (error) {
+        console.error('Error extracting blob:', error)
+        if (error instanceof Error) {
+          fileError('INVALID_FILE_TYPE', error.message)
+        }
+      }
+    }
+
     reader.readAsText(file)
   }
 }
diff --git a/protocol-designer/src/load-file/utils.ts b/protocol-designer/src/load-file/utils.ts
@@ -1,13 +1,20 @@
 import { saveAs } from 'file-saver'
 import type { ProtocolFile } from '@opentrons/shared-data'
+import type { PDPythonFile } from '../file-types'
+
 export const saveFile = (fileData: ProtocolFile, fileName: string): void => {
   const blob = new Blob([JSON.stringify(fileData, null, 2)], {
     type: 'application/json',
   })
   saveAs(blob, fileName)
 }
-export const savePythonFile = (fileData: string, fileName: string): void => {
-  const blob = new Blob([fileData], { type: 'text/x-python;charset=UTF-8' })
+export const savePythonFile = (file: PDPythonFile, fileName: string): void => {
+  const fileData = file.pythonProtocol
+  const stringifiedBlob = JSON.stringify(file.designerApplication)
+  const designerApplicationBlob = `\nDESIGNER_APPLICATION = """${stringifiedBlob}"""\n`
+  const blob = new Blob([fileData, designerApplicationBlob], {
+    type: 'text/x-python;charset=UTF-8',
+  })
   // For now, show the generated Python in a new window instead of saving it to a file.
   // (A saved Python file wouldn't be runnable anyway until we finish this project.)
   window.open(URL.createObjectURL(blob), '_blank')
