HYTOS

                1] == '.jpeg' or os.path.splitext(f)[1] == '.JPEG' or os.path.splitext(f)[1] == '.PNG')]

            drawingFileList.sort()

        except Exception as ex:

                                                      sys.exc_info()[-1].tb_lineno))

        return drawingFileList

            drawingFileList.sort()

        except Exception as ex:

            from App import App

                                                          sys.exc_info()[-1].tb_lineno)

            App.mainWnd().addMessage.emit(MessageType.Error, message)

                # Catch the exception

                except Exception as ex:

                    from App import App

                                                                  sys.exc_info()[-1].tb_lineno)

                    App.mainWnd().addMessage.emit(MessageType.Error, message)

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

            finally:

                if rows is not None and len(rows) > 0:

                conn.rollback()

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

            finally:

                conn.rollback()

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

            finally:

                                            detectFlip=row[15])  ## uid is last item

                    targetSymbolList.append(sym)

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return targetSymbolList

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

                                                      sys.exc_info()[-1].tb_lineno))

        finally:

            # Close the db connection

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

                                                      sys.exc_info()[-1].tb_lineno))

        finally:

            # Close the db connection

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

                                                      sys.exc_info()[-1].tb_lineno))

        finally:

            # Close the db connection

                                    file.close()

                        conn.commit()

                except Exception as ex:

                                                              sys.exc_info()[-1].tb_lineno))

        # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

                                                      sys.exc_info()[-1].tb_lineno))

        finally:

            pass

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

                                                      sys.exc_info()[-1].tb_lineno))

        finally:

            # Close the db connection

                except Exception as ex:

                    # Roll back any change if something goes wrong

                    conn.rollback()

                                                              sys.exc_info()[-1].tb_lineno))

        # Catch the exception

        except Exception as ex:

                                                      sys.exc_info()[-1].tb_lineno))

        self._titleBlockProperties = None

                    res = self._titleBlockProperties

                # Catch the exception

                except Exception as ex:

                                                              sys.exc_info()[-1].tb_lineno))

        else:

            res = self._titleBlockProperties

                self._lineNoPropertiesUID[UID] = res

            # Catch the exception

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return res

                    res.append(line_type)

            # Catch the exception

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return res

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

    def removeProjectInfo(self, targetProject):

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

    '''

                    if os.path.isdir(row['Path']):  # check if folder exists

                        projectList.append(Project(row))

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return projectList

                    res[1] = int(config.value)

        # Catch the exception

        except Exception as ex:

                                                      sys.exc_info()[-1].tb_lineno))

        return res

                        res = rows[0][2].split(delimiter)

            # Catch the exception

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return res

                        self._areas.append(area)

                # Catch the exception

                except Exception as ex:

                                                              sys.exc_info()[-1].tb_lineno))

        return self._areas

                        self._configs.append(Config(row[0], row[1], row[2]))

                # Catch the exception

                except Exception as ex:

                                                              sys.exc_info()[-1].tb_lineno))

        if key is not None:

                    res.append(Config(row[0], row[1], row[2]))

            # Catch the exception

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return res

                conn.rollback()

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

    '''

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

    def deleteAppConfigs(self, section, key=None):

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

    '''

                conn.rollback()

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

            finally:

                for row in rows:

                    symbolNametList.append(row[4])  # Name String

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return symbolNametList

                    for row in rows:

                        symbolNametList.append(row[4])  # Name String

                except Exception as ex:

                                                              sys.exc_info()[-1].tb_lineno))

        return symbolNametList

                    ret = True

                except Exception as ex:

                    conn.rollback()

                                                              sys.exc_info()[-1].tb_lineno))

                    ret = False

            finally:

                                            detectFlip=symbolTuple[15])  ## uid is last item

                    self._symbolBase[fieldName][param] = ret

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return ret

                                                detectFlip=symbolTuple[15])  ## uid is last item

                        ret.append(sym)

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return ret

            # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                conn.rollback()

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                conn.commit()

            except Exception as ex:

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

    '''

                    result = rows[0][0]

                # Catch the exception

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return result

                result = rows[0][0]

                # Catch the exception

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return result

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

    '''

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

    '''

                        result.append(data)

                # Catch the exception

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return result

                    return False

                # Catch the exception

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return False

            # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                conn.rollback()

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                    result = -1

                # Catch the exception

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return result

            # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                conn.rollback()

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                conn.rollback()

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

            # catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                conn.rollback()

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

                                                      sys.exc_info()[-1].tb_lineno))

    '''

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

    def getDocumentNameList(self):

                result.sort()

            # Catch the exception

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return result

                    result.append(row[0])

            # Catch the exception

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return result

                    result.append(row[0])

            # Catch the exception

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return result

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

    '''

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

    '''

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

    '''

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

    '''

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

    '''

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                                                          sys.exc_info()[-1].tb_lineno))

    '''

            # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

            # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

            # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

            # Catch the exception

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                conn.rollback()

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                conn.rollback()

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                conn.rollback()

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                conn.rollback()

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                    symbolTypeList.append((row[0], row[1], row[2]))  # UID, category, type

            except Exception as ex:

                from App import App

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

                    category = rows[0][0]

                    self._symbolType[type] = category

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return category

                        res.append(row[0])

            # Catch the exception

            except Exception as ex:

                                                          sys.exc_info()[-1].tb_lineno))

        return res

                # Roll back any change if something goes wrong

                conn.rollback()

                err = True

                                                          sys.exc_info()[-1].tb_lineno))

            finally:

                return (True if not err else False)

                # Roll back any change if something goes wrong

                conn.rollback()

                err = True

                                                          sys.exc_info()[-1].tb_lineno))

            finally:

                return (True if not err else False)

                self.checkRowAndAddRow(tableName, table)

                self.setCurrentCode(table, tableName)

        except Exception as ex:

    '''

        @brief      Insert row NominalPipeSzie Tablewidget

        except Exception as ex:

            from App import App

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

        except Exception as ex:

            from App import App

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

                        self.checkRowAndAddRow(tabText, table)

        except Exception as ex:

    '''

        @brief      Add new row

                    table.cellChanged.connect(self.cellValueChanged)

        except Exception as ex:

    '''

        @brief      cellValueChange event

            else:

                self.checkRowAndAddRow(tabText, table)

        except Exception as ex:

    '''

        @brief      Check Duplicate Code 

                return True

        except Exception as ex:

    '''

        @brief      save current Code (self.currentCode)

            self.currentCode[tabText] = res

        except Exception as ex:

    '''

        @brief      replaceTextForCodeTable

        except Exception as ex:

            from App import App

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

        except Exception as ex:

            from App import App

            App.mainWnd().addMessage.emit(MessageType.Error, message)

            from App import App 

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    def undo(self):

            QApplication.instance().setOverrideCursor(QCursor(Qt.DragCopyCursor))

        except Exception as ex:

            arr = np.array(ptr).reshape(height, width, 4)  #  Copies the data

            return arr

        except Exception as ex:

    '''

        @brief      get minimum image bouding box

        except Exception as ex:

            from AppDocData import MessageType

            self.display_message.emit(MessageType.Error, message)

    @staticmethod

            from App import App

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)       

        self.isTreated = True

            from App import App

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

            return (False,)

            self.removeArea(self.ui.tableWidgetTitleBlockArea.item(row, 2).tag)

            self.ui.tableWidgetTitleBlockArea.removeRow(row)

        except Exception as ex:

    '''

        @brief  select equipment desc area

        try:

            self.parent().graphicsView.scene.removeItem(box)

        except Exception as ex:

    '''

        @brief  delete selected equipment desc area

            from App import App

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    def onDeleteTypicalArea(self):

            from App import App

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

            self.isAccepted = True

        except Exception as ex:

        finally:

            pass

            from App import App

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

                from App import App

                from AppDocData import MessageType

                App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

            from App import App

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        finally:

            self.ui.tableWidgetColorProperty.resizeColumnsToContents()

            from App import App

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        QDialog.accept(self)

            connectAttrImpl(self, self._update_line_type, self._update_flow_mark, self._update_spec)

        except Exception as ex:

            from App import App 

            App.mainWnd().addMessage.emit(MessageType.Error, message)

class QConnectAttrDialog(QDialog):

            self.tmStart = timeit.default_timer()

        except Exception as ex:

            from App import App 

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        finally:

            self.ui.buttonBox.setDisabled(False)

        except Exception as ex:

            from App import App

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        finally:

            self.tmStop = timeit.default_timer()    

            self.ui.treeWidgetDrawingList.resizeColumnToContents(0)

        except Exception as ex:

            from App import App

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    def on_test_connection_clicked(self):

            QDialog.accept(self)

        except Exception as ex:

            from App import App

            App.mainWnd().addMessage.emit(MessageType.Error, message)

            from App import App 

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

            from App import App

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        finally:

            return items,tracer_line_nos

        try:

            self.tagNo = tagNo

        except Exception as ex:

        from App import App

        from AppDocData import MessageType

        message = 'Unhandled exception: {}'.format(message)

        self.errorSignal.emit()

        self.logger.critical(message)

            self.code = code

            self.description = description

        except Exception as ex:

            docData.setFluidCodeData(fluidCodes, self.removeFluidCode)

        except Exception as ex:

        QDialog.accept(self)

                self.checkRowAndAddRow()

        except Exception as ex:

    '''

            data = FluidCodeData(uid.text() ,codeItem.text(), descriptionItem.text())

        except Exception as ex:

        return data

                table.resizeColumnToContents(2)

        except Exception as ex:

    '''

                return True

        except Exception as ex:

    '''

        @brief      save current Code (self.currentCode)

                self.currentCode[row] = code

        except Exception as ex:

    '''

        @brief      Add new row

                table.cellChanged.connect(self.cellValueChanged)

        except Exception as ex:

        try:

            self.recognizeText.emit(self)

        except Exception as ex:

class QHMBDialog(QDialog):

    def __init__(self, parent):

            elif data.streamNo is None:

                data.streamNo = self.ui.tableWidgetHMBData.item(0, column).data(Qt.UserRole).streamNo

        except Exception as ex:

    '''

        @brief  add a record

                    self.ui.tableWidgetHMBData.hideColumn(item.column())

        except Exception as ex:

    '''

        @brief      recognize text in selected area

            textDetector.recognizeText(appDocData.imgSrc, (worker.area[0], worker.area[1]), texts, [], worker, None, len(texts))

            worker.textInfoList = textDetector.textInfoList.copy()

        except Exception as ex:

        finally:

            worker.finished.emit()

            self.ui.progressBar.setValue(self.ui.progressBar.maximum())

            self.ui.buttonBox.setEnabled(True)

        except Exception as ex:

        finally:

            pass

            appDocData.hmbTable.saveData()

            # up to here

        except Exception as ex:

        finally:

            if self.ui.lineEditHMBArea.tag is not None:

                self.parent().graphicsView.scene.removeItem(self.ui.lineEditHMBArea.tag)

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

        finally:

            conn.close()

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

        finally:

            # Close the db connection

            conn.close()

                    from App import App 

                    from AppDocData import MessageType

                    App.mainWnd().addMessage.emit(MessageType.Error, message)

        QMessageBox.information(self, self.tr('Information'), self.tr('Importing Success!'), QMessageBox.Close)

            from App import App

            from AppDocData import MessageType

                                                          sys.exc_info()[-1].tb_lineno)

            App.mainWnd().addMessage.emit(MessageType.Error, message)

            from App import App

            from AppDocData import MessageType

                                                          sys.exc_info()[-1].tb_lineno)

            App.mainWnd().addMessage.emit(MessageType.Error, message)

            from App import App

            from AppDocData import MessageType

                                                          sys.exc_info()[-1].tb_lineno)

            App.mainWnd().addMessage.emit(MessageType.Error, message)

            QDialog.keyPressEvent(self, event)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

            return None

        except Exception as ex:

            from App import App 

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        finally:

            self.blockSignals(False)

        except Exception as ex:

            from App import App 

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

                except Exception as ex:

                    from App import App 

                    App.mainWnd().addMessage.emit(MessageType.Error, message)

    def show_item_attributes(self, item):

                except Exception as ex:

                        from App import App 

                        App.mainWnd().addMessage.emit(MessageType.Error, message)

    def show_item_connectors(self, item):

        except Exception as ex:

            from App import App 

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

            from App import App

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

                        dialog.exec_()

                        self.show_item_property(items[0])

                    except Exception as ex:

            elif issubclass(type(attr), SymbolProp):

                attr = keyCell.data(Qt.UserRole)

                cmd = SelectAttributeCommand.SelectAttributeCommand(items[0], attr, self.mainWindow.graphicsView)

            else:

                event.ignore()

        except Exception as ex:

    '''

        @brief      Show Context Menu

            from App import App

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        return item

            from App import App

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        finally:

            pass

            from App import App

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

            self.width, self.height = self._image.shape[::-1]

            self.Result = np.zeros((self.width, self.height, 3), np.uint8)

        except Exception as ex:

    '''

        @brief  dot product of given two vectors

            return (len(matches) == 1)

        except Exception as ex:

        return False

                return (math.sqrt(dx*dx + dy*dy) < 0.00001)

        except Exception as ex:

        return False

            from App import App 

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message) if not 'is out of bounds' in message else ''

            return (pt, -1)