Coverage for backend/migration_helper/get_flowsheet_related_objects.py: 23%

1from functools import cached_property 

2 

3def get_many(item, attr): 

4 related_manager = getattr(item, attr, None) 

5 if related_manager is not None: 

6 return related_manager.all() 

7 return [] 

8 

9 

10def get_one_one(item, attr): 

11 item = getattr(item, attr, None) 

12 if item is not None: 

13 return [item] 

14 return [] 

15 

16 

17class GetObjectFunctions: 

18 def __init__(self, flowsheet): 

19 self.flowsheet = flowsheet 

20 self.related_objects = [] 

21 

22 def get_related_objects(self): 

23 self.related_objects.extend(self.getPlot) 

24 self.related_objects.extend(self.getSeries) 

25 self.related_objects.extend(self.getIndexedItem) 

26 self.related_objects.extend(self.getSolutions) 

27 self.related_objects.extend(self.getControlValue) 

28 self.related_objects.extend(self.getPropertyValue) 

29 self.related_objects.extend(self.getHistoricalValue) 

30 self.related_objects.extend(self.getProcessPathProperty) 

31 self.related_objects.extend(self.getPropertyInfo) 

32 self.related_objects.extend(self.getPropertySet) 

33 self.related_objects.extend(self.getRecycleData) 

34 self.related_objects.extend(self.getRecycleProperty) 

35 self.related_objects.extend(self.getObjectUnits) 

36 self.related_objects.extend(self.getNote) 

37 self.related_objects.extend(self.getExpression) 

38 self.related_objects.extend(self.getProcessPath) 

39 self.related_objects.extend(self.getMLColumnMapping) 

40 self.related_objects.extend(self.getMLModel) 

41 self.related_objects.extend(self.getOptimization) 

42 self.related_objects.extend(self.getOptimizationDegreesOfFreedom) 

43 self.related_objects.extend(self.getSolveState) 

44 self.related_objects.extend(self.getSolveValue) 

45 self.related_objects.extend(self.getFormulaVars) 

46 self.related_objects.extend(self.getPort) 

47 self.related_objects.extend(self.getSimulationObject) 

48 self.related_objects.extend(self.getGraphicObject) 

49 self.related_objects.extend(self.getGrouping) 

50 self.related_objects.extend(self.getSimulationObjectPropertyPackages) 

51 self.related_objects.extend(self.getPinchOutputs) 

52 self.related_objects.extend(self.getPinchTemp) 

53 self.related_objects.extend(self.getTargetSummary) 

54 self.related_objects.extend(self.getHeatSupplierUtilitySummary) 

55 self.related_objects.extend(self.getHeatReceiverUtilitySummary) 

56 self.related_objects.extend(self.getPinchGraphSet) 

57 self.related_objects.extend(self.getPinchGraph) 

58 self.related_objects.extend(self.getPinchCurve) 

59 self.related_objects.extend(self.getGraphDataPoint) 

60 self.related_objects.extend(self.getPinchInputs) 

61 self.related_objects.extend(self.getPinchStream) 

62 self.related_objects.extend(self.getPinchUtility) 

63 self.related_objects.extend(self.getTurbineOptions) 

64 self.related_objects.extend(self.getGraphOptions) 

65 self.related_objects.extend(self.getMainOptions) 

66 self.related_objects.extend(self.getPinchProject) 

67 

68 return self.related_objects 

69 

70 @cached_property 

71 def getPlot(self): 

72 return get_many(self.flowsheet, "flowsheetGraphs") 

73 

74 @cached_property 

75 def getSeries(self): 

76 series = [] 

77 for plot in self.getPlot: 

78 series.extend(get_many(plot, "series")) 

79 return series 

80 

81 @cached_property 

82 def getIndexedItem(self): 

83 indexed_items = [] 

84 for sim_obj in self.getSimulationObject: 

85 indexed_items.extend(get_many(sim_obj, "indexed_items")) 

86 return indexed_items 

87 

88 @cached_property 

89 def getSolutions(self): 

90 dynamic_results = [] 

91 for prop_val in self.getPropertyValue: 

92 dynamic_results.extend(get_many(prop_val, "solutions")) 

93 return dynamic_results 

94 

95 @cached_property 

96 def getControlValue(self): 

97 control_values = [] 

98 for prop_val in self.getPropertyValue: 

99 control_values.extend(get_one_one(prop_val, "controlManipulated")) 

100 control_values.extend(get_one_one(prop_val, "controlSetPoint")) 

101 return control_values 

102 

103 @cached_property 

104 def getPropertyValue(self): 

105 property_values = [] 

106 for prop_info in self.getPropertyInfo: 

107 property_values.extend(get_many(prop_info, "values")) 

108 return property_values 

109 

110 @cached_property 

111 def getHistoricalValue(self): 

112 historical_values = [] 

113 for prop_info in self.getPropertyInfo: 

114 historical_values.extend(get_many(prop_info, "history")) 

115 return historical_values 

116 

117 @cached_property 

118 def getProcessPathProperty(self): 

119 process_path_properties = [] 

120 for prop_info in self.getPropertyInfo: 

121 process_path_properties.extend( 

122 get_many(prop_info, "ProcessPathProperties")) 

123 return process_path_properties 

124 

125 @cached_property 

126 def getPropertyInfo(self): 

127 property_infos = [] 

128 for prop_set in self.getPropertySet: 

129 property_infos.extend(get_many(prop_set, "ContainedProperties")) 

130 return property_infos 

131 

132 @cached_property 

133 def getPropertySet(self): 

134 property_sets = [] 

135 for sim_obj in self.getSimulationObject: 

136 property_sets.extend(get_one_one(sim_obj, "properties")) 

137 

138 for main_option in self.getMainOptions: 

139 property_sets.append(main_option.selections) 

140 property_sets.append(main_option.graph_options.properties) 

141 property_sets.append(main_option.turbine_options.properties) 

142 

143 return property_sets 

144 

145 @cached_property 

146 def getRecycleData(self): 

147 recycle_datas = [] 

148 for sim_obj in self.getSimulationObject: 

149 recycle_datas.extend(get_one_one(sim_obj, "recycleData")) 

150 recycle_datas.extend(get_one_one(sim_obj, "recycleConnection")) 

151 return recycle_datas 

152 

153 @cached_property 

154 def getRecycleProperty(self): 

155 recycle_properties = [] 

156 for recycle_data in self.getRecycleData: 

157 recycle_properties.extend( 

158 get_many(recycle_data, "propertyConnections")) 

159 return recycle_properties 

160 

161 @cached_property 

162 def getObjectUnits(self): 

163 # have to comply with the old db schema 

164 return get_many(self.flowsheet, "flowsheetOwner") 

165 

166 @cached_property 

167 def getNote(self): 

168 notes = [] 

169 for sim_obj in self.getSimulationObject: 

170 notes.extend(get_many(sim_obj, "notes")) 

171 return notes 

172 

173 @cached_property 

174 def getExpression(self): 

175 return get_many(self.flowsheet, "expressions") 

176 

177 @cached_property 

178 def getProcessPath(self): 

179 return get_many(self.flowsheet, "ProcessPaths") 

180 

181 @cached_property 

182 def getMLColumnMapping(self): 

183 ml_column_mappings = [] 

184 for ml_model in self.getMLModel: 

185 ml_column_mappings.extend( 

186 get_many(ml_model, "MLColumnMappings")) 

187 return ml_column_mappings 

188 

189 @cached_property 

190 def getMLModel(self): 

191 ml_models = [] 

192 for sim_obj in self.getSimulationObject: 

193 ml_models.extend(get_many(sim_obj, "MLModels")) 

194 return ml_models 

195 

196 @cached_property 

197 def getOptimization(self): 

198 optimizations = [] 

199 for sim_obj in self.getSimulationObject: 

200 optimizations.extend(get_many(sim_obj, "optimizations")) 

201 return optimizations 

202 

203 @cached_property 

204 def getOptimizationDegreesOfFreedom(self): 

205 optimization_dofs = [] 

206 for optimizations in self.getOptimization: 

207 optimization_dofs.extend(get_many( 

208 optimizations, "degreesOfFreedom")) 

209 return optimization_dofs 

210 

211 @cached_property 

212 def getSolveState(self): 

213 return get_many(self.flowsheet, "solveStates") 

214 

215 @cached_property 

216 def getSolveValue(self): 

217 solve_values = [] 

218 for solve_state in self.getSolveState: 

219 solve_values.extend(get_many(solve_state, "values")) 

220 return solve_values 

221 

222 @cached_property 

223 def getFormulaVars(self): 

224 formula_vars = [] 

225 for prop_val in self.getPropertyValue: 

226 formula_vars.extend(get_many(prop_val, "ownerFormulaVars")) 

227 formula_vars.extend(get_many(prop_val, "attributeFormulaVars")) 

228 return formula_vars 

229 

230 @cached_property 

231 def getPort(self): 

232 ports = [] 

233 for sim_obj in self.getSimulationObject: 

234 if hasattr(sim_obj, 'ports'): 

235 ports.extend(get_many(sim_obj, "ports")) 

236 elif hasattr(sim_obj, 'connectedPorts'): 

237 ports.extend(get_many(sim_obj, "connectedPorts")) 

238 else: 

239 raise ValueError( 

240 f"SimulationObject {sim_obj} does not have ports or connectedPorts attribute.") 

241 return ports 

242 

243 @cached_property 

244 def getSimulationObject(self): 

245 return get_many(self.flowsheet, "flowsheetObjects") 

246 

247 @cached_property 

248 def getGraphicObject(self): 

249 graphic_objects = [] 

250 for sim_obj in self.getSimulationObject: 

251 graphic_objects.extend(get_many(sim_obj, "graphicObject")) 

252 

253 for grouping in self.getGrouping: 

254 graphic_objects.extend(get_many(grouping, "graphicObjects")) 

255 

256 return graphic_objects 

257 

258 @cached_property 

259 def getGrouping(self): 

260 groupings = [] 

261 for sim_obj in self.getSimulationObject: 

262 groupings.extend(get_one_one(sim_obj, "grouping")) 

263 return groupings 

264 

265 @cached_property 

266 def getSimulationObjectPropertyPackages(self): 

267 property_packages = [] 

268 for sim_obj in self.getSimulationObject: 

269 property_packages.extend(get_many(sim_obj, "propertyPackages")) 

270 return property_packages 

271 

272 @cached_property 

273 def getPinchOutputs(self): 

274 pinch_outputs = [] 

275 for pinch_project in self.getPinchProject: 

276 pinch_outputs.extend(get_one_one(pinch_project, "Outputs")) 

277 return pinch_outputs 

278 

279 @cached_property 

280 def getPinchTemp(self): 

281 pinch_temps = [] 

282 for target_summary in self.getTargetSummary: 

283 pinch_temps.append(target_summary.temp_pinch) 

284 return pinch_temps 

285 

286 @cached_property 

287 def getTargetSummary(self): 

288 target_summaries = [] 

289 for pinch_output in self.getPinchOutputs: 

290 target_summaries.extend(get_many(pinch_output, "targets")) 

291 return target_summaries 

292 

293 @cached_property 

294 def getHeatSupplierUtilitySummary(self): 

295 heat_supplier_utilities = [] 

296 for target_summary in self.getTargetSummary: 

297 heat_supplier_utilities.extend(get_many( 

298 target_summary, "heat_supplier_utilities")) 

299 return heat_supplier_utilities 

300 

301 @cached_property 

302 def getHeatReceiverUtilitySummary(self): 

303 heat_receiver_utilities = [] 

304 for target_summary in self.getTargetSummary: 

305 heat_receiver_utilities.extend(get_many( 

306 target_summary, "heat_receiver_utilities")) 

307 return heat_receiver_utilities 

308 

309 @cached_property 

310 def getPinchGraphSet(self): 

311 pinch_graph_sets = [] 

312 for output in self.getPinchOutputs: 

313 pinch_graph_sets.extend(get_many(output, "graph_sets")) 

314 return pinch_graph_sets 

315 

316 @cached_property 

317 def getPinchGraph(self): 

318 pinch_graphs = [] 

319 for graph_set in self.getPinchGraphSet: 

320 pinch_graphs.extend(get_many(graph_set, "graphs")) 

321 return pinch_graphs 

322 

323 @cached_property 

324 def getPinchCurve(self): 

325 pinch_curves = [] 

326 for graph in self.getPinchGraph: 

327 pinch_curves.extend(get_many(graph, "segments")) 

328 return pinch_curves 

329 

330 @cached_property 

331 def getGraphDataPoint(self): 

332 graph_data_points = [] 

333 for curve in self.getPinchCurve: 

334 graph_data_points.extend(get_many(curve, "data_points")) 

335 return graph_data_points 

336 

337 @cached_property 

338 def getPinchInputs(self): 

339 pinch_inputs = [] 

340 for pinch_project in self.getPinchProject: 

341 pinch_inputs.extend(get_one_one(pinch_project, "Inputs")) 

342 return pinch_inputs 

343 

344 @cached_property 

345 def getPinchStream(self): 

346 pinch_streams = [] 

347 for pinch_input in self.getPinchInputs: 

348 pinch_streams.extend(get_many(pinch_input, "PinchStreams")) 

349 return pinch_streams 

350 

351 @cached_property 

352 def getPinchUtility(self): 

353 pinch_utilities = [] 

354 for pinch_input in self.getPinchInputs: 

355 pinch_utilities.extend(get_many(pinch_input, "PinchUtilities")) 

356 return pinch_utilities 

357 

358 @cached_property 

359 def getTurbineOptions(self): 

360 turbine_options = [] 

361 for main_option in self.getMainOptions: 

362 turbine_options.append(main_option.turbine_options) 

363 return turbine_options 

364 

365 @cached_property 

366 def getGraphOptions(self): 

367 graph_options = [] 

368 for main_option in self.getMainOptions: 

369 graph_options.append(main_option.graph_options) 

370 return graph_options 

371 

372 @cached_property 

373 def getMainOptions(self): 

374 main_options = [] 

375 for pinch_projects in self.getPinchProject: 

376 main_options.extend(get_one_one(pinch_projects, "Options")) 

377 return main_options 

378 

379 @cached_property 

380 def getPinchProject(self): 

381 return get_many(self.flowsheet, "pinchProjects")