HYTOS

    @staticmethod

    def save_stream_line_data(stream_line_list: list):

        import uuid

        app_doc_data = AppDocData.instance()

        with app_doc_data.project.database.connect() as conn:

            try:

                cursor = conn.cursor()

                for stream_line in stream_line_list:

                    sql = f"insert into Streamlines(HMB_UID,[From],[To]) values" \

                          f"((select UID from HMB where StreamNumber=?),?,?)"

                    params = (stream_line[0], stream_line[1], stream_line[2])

                    affected = cursor.execute(sql, params)

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                from App import App

                message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                          f"{sys.exc_info()[-1].tb_lineno}"

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

    def get_stream_lines(self, hmb_uid: str) -> list:

        """get stream lines related to hmb"""

        with self.project.database.connect() as conn:

            try:

                # Get a cursor object

                cursor = conn.cursor()

                sql = f"select * from Streamlines where HMB_UID = ?"

                sql = self.project.database.to_sql(sql)

                params = (hmb_uid,)

                cursor.execute(sql, params)

                return cursor.fetchall()

            # Catch the exception

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                from App import App

                message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                          f"{sys.exc_info()[-1].tb_lineno}"

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

            stream_lines = []

                stream_no = sheet.cell(row=1, column=col).value

                from_ = sheet.cell(row=2, column=col).value

                to_ = sheet.cell(row=3, column=col).value

                hmb.stream_no = stream_no

                stream_lines.append((stream_no, from_, to_))

            AppDocData.save_stream_line_data(stream_lines)

    UID                                  VARCHAR (37) PRIMARY KEY,

    StreamNumber                         TEXT,

    StreamDescription                    TEXT,

    DATACASE                             TEXT,

    STREAMPHASE                          TEXT,

    Unitno                               TEXT,

    OVERALLVAPORFRACTION                 TEXT,

    OVERALLTEMPERATURE                   TEXT,

    OVERALLPRESSURE                      TEXT,

    OVERALLMOLECULARWEIGHT               TEXT,

    OVERALLMOLARFLOW                     TEXT,

    OVERALLMASSFLOW                      TEXT,

    OVERALLACTUALVOLUMEFLOW              TEXT,

    OVERALLMASSDENSITY                   TEXT,

    OVERALLVISCOSITY                     TEXT,

    OVERALLMASSHEATCAPACITY              TEXT,

    OVERALLHEATFLOW                      TEXT,

    OverallMassEnthalpy                  TEXT,

    [OverallSp.Gravity]                  TEXT,

    OverallAPIGravity                    TEXT,

    OverallCriticalPressure              TEXT,

    OverallCriticalTemperature           TEXT,

    OverallUOPKfactor                    TEXT,

    LIQUIDMOLEFRACTION                   TEXT,

    VaporTemperature                     TEXT,

    VaporPressure                        TEXT,

    VaporPseudocriticalTemperature       TEXT,

    VaporPseudocriticalPressure          TEXT,

    VAPORMOLARRATE                       TEXT,

    VAPORMASSRATE                        TEXT,

    VAPORACTUALVOLUMERATE                TEXT,

    [VAPORSTD.VOLUMERATE]                TEXT,

    VAPORMOLECULARWEIGHT                 TEXT,

    VaporHeatFlow                        TEXT,

    VAPORCOMPRESSIBILITY                 TEXT,

    VAPORSPECIFICENTHALPY                TEXT,

    VAPORSPECIFICHEATCAPACITY            TEXT,

    IDEALVAPORSPECIFICHEATRATIO          TEXT,

    VAPORACTUALDENSITY                   TEXT,

    VAPORTHERMALCONDUCTIVITY             TEXT,

    VAPORVISCOSITY                       TEXT,

    LiquidTemperature                    TEXT,

    LiquidPressure                       TEXT,

    LiquidPseudocriticalTemperature      TEXT,

    LiquidPseudocriticalPressure         TEXT,

    LIQUIDMOLARRATE                      TEXT,

    LIQUIDMASSRATE                       TEXT,

    LIQUIDACTUALVOLUMEFLOW               TEXT,

    [LIQUIDSTD.VOLUMEFLOW]               TEXT,

    LIQUIDMOLECULARWEIGHT                TEXT,

    LiquidHeatFlow                       TEXT,

    LIQUIDSPECIFICENTHALPY               TEXT,

    LIQUIDBoilingPointPressureatStreamT  TEXT,

    LIQUIDSPECIFICHEATCAPACITY           TEXT,

    LIQUIDACTUALDENSITY                  TEXT,

    LiquidStdDensity                     TEXT,

    [LiquidSpecificGravity@15°C]         TEXT,

    LIQUIDSURFACETENSION                 TEXT,

    LIQUIDTHERMALCONDUCTIVITY            TEXT,

    LIQUIDVISCOSITY                      TEXT,

    AQUEOUSPseudocriticalTemperature     TEXT,

    AQUEOUSPseudocriticalPressure        TEXT,

    AQUEOUSMOLARRATE                     TEXT,

    AQUEOUSMASSRATE                      TEXT,

    AQUEOUSACTUALVOLUMEFLOW              TEXT,

    [AQUEOUSSTD.LIQUIDFLOW]              TEXT,

    AQUEOUSMolecularWeight               TEXT,

    AQUEOUSHeatFlow                      TEXT,

    AQUEOUSSPECIFICENTHALPY              TEXT,

    AQUEOUSBoilingPointPressureatStreamT TEXT,

    AQUEOUSSPECIFICHEATCAPACITY          TEXT,

    AQUEOUSACTUALDENSITY                 TEXT,

    AQUEOUSStdDensity                    TEXT,

    [AQUEOUSSpecificGravity@15°C]        TEXT,

    AQUEOUSSURFACETENSION                TEXT,

    AQUEOUSTHERMALCONDUCTIVITY           TEXT,

    AQUEOUSVISCOSITY                     TEXT,

    DataSource                           TEXT

);

CREATE TABLE IF NOT EXISTS Streamlines (

    UID     INTEGER      PRIMARY KEY AUTOINCREMENT

                         NOT NULL,

    HMB_UID VARCHAR (37) REFERENCES HMB (UID) ON DELETE CASCADE,

    [From]  VARCHAR (37) REFERENCES Components (UID) ON DELETE SET NULL,

    [To]    VARCHAR (37) REFERENCES Components (UID) ON DELETE SET NULL

        self.ui.tableViewStreamNo.selectionModel().selectionChanged.connect(self.on_selection_changed)

    def on_selection_changed(self, selection):

        """show stream line from, to related to selected hmb"""

        if selection.indexes():

            row = selection.indexes()[0].row()

            uid = self.ui.tableViewStreamNo.model().item(row, 0).text()

            if not self.ui.tableViewFromTo.model():

                model = QStandardItemModel()

                self.ui.tableViewFromTo.setModel(model)

            model = self.ui.tableViewFromTo.model()

            model.clear()

            app_doc_data = AppDocData.instance()

            rows = app_doc_data.get_stream_lines(uid)

            for row_ in rows:

                from_ = row_['From_UID'] if row_['From_UID'] else row_['From']

                to_ = row_['To_UID'] if row_['To_UID'] else row_['To']

                items = [QStandardItem(''), QStandardItem(from_), QStandardItem(to_)]

                model.appendRow(items)

            model.setHorizontalHeaderLabels(['Drawing No', 'From', 'To'])

            self.ui.tableViewFromTo.setModel(model)

            self.ui.tableViewFromTo.resizeColumnsToContents()

            """Properties"""

            if not self.ui.tableViewProperties.model():

                model_property = QStandardItemModel()

                self.ui.tableViewProperties.setModel(model_property)

            model_property = self.ui.tableViewProperties.model()

            model_property.clear()

            for col in range(self.ui.tableViewStreamNo.model().columnCount()):

                value = self.ui.tableViewStreamNo.model().item(row, col).text()

                property_ = self.ui.tableViewStreamNo.model().headerData(col, Qt.Horizontal)

                items = [QStandardItem(property_), QStandardItem(value)]

                model_property.appendRow(items)

            model_property.setHorizontalHeaderLabels(['Property', 'Value'])

            self.ui.tableViewProperties.setModel(model_property)

            self.ui.tableViewProperties.resizeColumnsToContents()

            self.ui.tableViewProperties.setEditTriggers(QAbstractItemView.NoEditTriggers)

            self.ui.tableViewProperties.setRowHidden(0, True)  # hide all columns except index is 1

       <widget class="QTableView" name="tableViewStreamNo">

        <property name="selectionBehavior">

         <enum>QAbstractItemView::SelectRows</enum>

        </property>

        <attribute name="horizontalHeaderStretchLastSection">

         <bool>true</bool>

        </attribute>

       </widget>

        <widget class="QTableView" name="tableViewProperties"/>

        self.tableViewStreamNo.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)

        self.tableViewStreamNo.horizontalHeader().setStretchLastSection(True)

        self.tableViewProperties = QtWidgets.QTableView(self.splitterVertical)

        self.tableViewProperties.setObjectName("tableViewProperties")