HYTOS

                    """delete stream line which has stream number is given data"""

                    sql = "delete from Streamlines where HMB_UID=(select UID from HMB where StreamNumber=?)"

                    params = (stream_line[0],)

                    cursor.execute(sql, params)

                    """up to here"""

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

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

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

                    if len(stream) != 2 or len(values) % 2 != 0:

# coding: utf-8

""" This is select component command module """

import os.path

import sys

import AbstractCommand

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR, QEvent

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImge, QPixmap, QPainterPath, QFileDialog, QCursor, QMouseEvent

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

class SelectCompCommand(AbstractCommand.AbstractCommand):

    """select component command"""

    onSuccess = pyqtSignal(QGraphicsItem)

    def __init__(self, imageViewer):

        super(SelectCompCommand, self).__init__(imageViewer)

        self.name = 'SelectComponent'

        self.imageViewer.setCursor(QCursor(Qt.ArrowCursor))

        self._selected = None

    @property

    def selected(self):

        return self._selected

    def execute(self, param):

        """select a component"""

        from SymbolAttr import SymbolAttr

        from SymbolAttr import SymbolProp

        event = param[1]

        scenePos = param[2]

        try:

            if 'mouseReleaseEvent' == param[0] and event.button() == Qt.LeftButton:

                from SymbolSvgItem import SymbolSvgItem

                from EngineeringLineItem import QEngineeringLineItem

                item = self.imageViewer.scene().itemAt(scenePos, QTransform())

                if item and (issubclass(type(item), SymbolSvgItem) or issubclass(type(item), QEngineeringLineItem)):

                    self._selected = item

                    self.onSuccess.emit(item)

                    self.isTreated = True

            elif 'keyPressEvent' == param[0]:

                if event.key() == Qt.Key_Escape:

                    self.onRejected.emit(self)

                    self.isTreated = False

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            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 undo(self):

        pass

    def redo(self):

        pass

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

# Form implementation generated from reading ui file '.\UI\MainWindow.ui'

# Created by: PyQt5 UI code generator 5.13.1

        self.toolBar.addAction(self.actionLineRecognition)

from functools import partial

class FromToModel(QStandardItemModel):

    def __init__(self, parent=None, *args):

        QStandardItemModel.__init__(self, parent, *args)

        self._need_to_pick_backcolor = QColor(255, 0, 255)

    def data(self, index, role):

        if not index.isValid():

            return None

        if role in [Qt.BackgroundRole]:

            if index.column() in [1, 2]:

                uid = super(FromToModel, self).item(index.row(), index.column()).data(Qt.UserRole)

                if not uid:

                    return self._need_to_pick_backcolor

        return super(FromToModel, self).data(index, role)

    def __init__(self, parent, column: int, from_to: str = ''):

        self._column = column

        pick.clicked.connect(partial(parent.parent().parent().parent().on_select_comp, self._column))

        self._from_to_widgets = {}

                model = FromToModel()

            self._from_to_widgets.clear()

                from_button = FromToWidget(self.ui.tableViewFromTo, 1, data)

                self._from_to_widgets[from_button] = (row, 1)

                to_button = FromToWidget(self.ui.tableViewFromTo, 2, data)

                self._from_to_widgets[to_button] = (row, 2)

        self.ui.tableViewFromTo.model().insertRow(rows, [QStandardItem(), QStandardItem(), QStandardItem()])

        from_button = FromToWidget(self.ui.tableViewFromTo, 1)

        self._from_to_widgets[from_button] = (i.row(), 1)

        to_button = FromToWidget(self.ui.tableViewFromTo, 2)

        self._from_to_widgets[to_button] = (i.row(), 2)

    def on_select_comp(self, column: int):

        """select from or to component"""

        from App import App

        from Commands.SelectCompCommand import SelectCompCommand

        def on_success_select_comp(selected):

            current = self.ui.tableViewFromTo.selectionModel().currentIndex()

            row = self.ui.tableViewFromTo.model().item(current.row(), 0)

            column = row.data(Qt.UserRole)

            item = self.ui.tableViewFromTo.model().item(current.row(), column)

            item.setText(str(selected))

            item.setData(str(selected.uid), Qt.UserRole)

            App.mainWnd().graphicsView.useDefaultCommand()

        # save column index

        if self.sender().parent() in self._from_to_widgets:

            row, column = self._from_to_widgets[self.sender().parent()]

            item = self.ui.tableViewFromTo.model().item(row, 0)

            item.setData(column, Qt.UserRole)

            self.ui.tableViewFromTo.setCurrentIndex(self.ui.tableViewFromTo.model().index(row, column))

        # up to here

        cmd = SelectCompCommand(App.mainWnd().graphicsView)

        cmd.onSuccess.connect(on_success_select_comp)

        App.mainWnd().graphicsView.command = cmd

        """save current from/to data"""

        row = self.ui.tableViewStreamNo.selectionModel().currentIndex().row()

        stream_no = self.ui.tableViewStreamNo.model().item(row, 1).text()

        from_to_data = []

        model = self.ui.tableViewFromTo.model()

        for row in range(model.rowCount()):

            from_ = model.item(row, 1)

            from_uid = from_.data(Qt.UserRole)

            to_ = model.item(row, 1)

            to_uid = to_.data(Qt.UserRole)

            from_to_data.append((stream_no, from_uid, from_.text(), to_uid, to_.text()))

        AppDocData.save_stream_line_data(from_to_data)

    <width>104</width>

    <height>62</height>

     <item row="2" column="0">

      <widget class="QRadioButton" name="radioButtonByStreamNo">

       <property name="text">

        <string>By Stream No</string>

       </property>

      </widget>

     </item>

   <addaction name="actionLineRecognition"/>