HYTOS

        self._lineNoProperties = None

        res = None

        if self._lineNoProperties is None:

            try:

                self._lineNoProperties = []

                # Creates or opens a file called mydb with a SQLite3 DB

                dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), 'ITI_PID.db')

                db = sqlite3.connect(dbPath)

                # Get a cursor object

                cursor = db.cursor()

                sql = "select UID, Name, DisplayName, Type, LimitNumber, [index] from LineProperties order by [index]" 

                cursor.execute(sql)

                rows = cursor.fetchall()

                for row in rows:

                    attr = SymbolAttr()

                    attr.UID = row[0]

                    attr.Attribute = row[1]

                    attr.DisplayAttribute = row[2]

                    attr.AttributeType = row[3]

                    attr.Length = row[4]

                    self._lineNoProperties.append(attr)

                res = self._lineNoProperties

            # Catch the exception

            except Exception as ex:

                # Roll back any change if something goes wrong

                db.rollback()

                print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))

            finally:

                # Close the db connection

                db.close()

        else:

            res = self._lineNoProperties

            self._lineNoProperties = None

from EngineeringNoteItem import QEngineeringNoteItem

        from EngineeringEquipmentItem import QEngineeringEquipmentItem

        from EngineeringNoteItem import QEngineeringNoteItem

from EngineeringNoteItem import QEngineeringNoteItem

                self.setRowCount(1)

                self.setItem(0, 0, QTableWidgetItem("UID"))

        configs = appDocData.getConfigs('Line No', 'Configuration')

        configs = configs[0].value.split('"-"')

        item = QTableWidgetItem(str(lineNoItem.uid))

        item.setFlags(Qt.ItemIsEnabled)

        self.setItem(0, 1, item)

        row = self.rowCount()

        attrs = lineNoItem.getAttributes()

        self.setRowCount(row + len(attrs))

        if attrs is not None:

            for key in attrs.keys():

                item = QTableWidgetItem(key.DisplayAttribute if key.DisplayAttribute else key.Attribute)

                item.setFlags(Qt.ItemIsEnabled)

                item.setBackground(QColor(220, 220, 220))

                item.tag = key

                self.setItem(row, 0, item)

                value = attrs[key]

                keyStr = appDocData.getLinePropertiesByUID(key.UID)

                        self.attrValueList.append((valueCell, key.Attribute))

                    if keyStr[0].UID in configs: valueCell.setFlags(Qt.ItemIsEnabled)

                else:

                    valueCell.setFlags(Qt.ItemIsEnabled)

                if key.Attribute == 'Stream No':

                    self.setCellWidget(row, 1, self.streamNoComboBox)

                    if key.Attribute == 'CONN':

                self.setItem(row, 1, valueCell)

                row = row + 1

        cell = self.item(row, 0)

        if not hasattr(cell, 'tag'): return

        key = self.item(row, 0).tag

        items = self.mainWindow.graphicsView.scene.selectedItems()

        if items is not None and len(items) == 1:

            if type(items[0]) is QEngineeringLineNoTextItem:

                items[0].setAttribute(key, cell.text())

                #param = [param for param in items[0].attrs.keys() if param.UID == key.UID]

                #if param:

                return

        """

        """

            elif Qt.ItemIsEnabled is not self.item(row, column):

                self.editItem(self.item(row, column))

from EngineeringNoteItem import QEngineeringNoteItem

from EngineeringEquipmentItem import QEngineeringEquipmentItem

from EngineeringNoteItem import QEngineeringNoteItem

from EngineeringEquipmentItem import QEngineeringEquipmentItem

        appDocData.saveToDatabase([item for item in items if type(item) is QEngineeringInstrumentItem or type(item) is QEngineeringEquipmentItem or\

        type(item) is QEngineeringNoteItem])

        try:

            appDocData = AppDocData.instance()

            appDocData.deleteDataListBeforeSave()

            QApplication.processEvents()

            self.drawDetectedSymbolItem(symbolList)

            QApplication.processEvents()

            self.drawDetectedTextItem(textInfoList)

            QApplication.processEvents()

            self.drawDetectedOtherTextItem(otherTextInfoList)

            appDocData.deleteDataListBeforeSave()

            items = self.graphicsView.scene.items()

            for item in items:

                if type(item) is QEngineeringLineNoTextItem:

                    item.saveLineData()

            appDocData.saveToDatabase([item for item in items if type(item) is QEngineeringInstrumentItem or type(item) is QEngineeringEquipmentItem or\

            type(item) is QEngineeringNoteItem])

            self.saveToXml(False)

            # update scene

            self.graphicsView.scene.update(self.graphicsView.sceneRect())

        except Exception as ex:

            message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)

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

                    """

                    """

	[1] EngineeringNoteItem

	TYPE TEXT,

# coding: utf-8

import sys

import os

import math

from PyQt5.QtGui import *

from PyQt5.QtCore import *

from PyQt5.QtSvg import *

from PyQt5.QtWidgets import (QApplication, QGraphicsItem)

from SymbolSvgItem import SymbolSvgItem

from EngineeringConnectorItem import QEngineeringConnectorItem

from EngineeringTextItem import QEngineeringTextItem

from UserInputAttribute import UserInputAttribute

equipColumnList = ['UID', 'ITEM_NO', 'SERVICE', 'NO_REQ', 'FLUID', 'DESC_OF_PART', 'OPERATION_CONDITION_TEMP', 'OPERATION_CONDITION_PRESS', 'DESIGN_CONDITION_TEMP', 'DESIGN_CONDITION_PRESS', 'MATERIAL', 'WEIGHT', 'POWER', 'INSULATION', 'PNID_NO', 'REV']

class QEngineeringEquipmentItem(SymbolSvgItem):

    clicked = pyqtSignal(QGraphicsSvgItem)

    ZVALUE = 10

    '''

    '''

    def __init__(self, path, uid=None):

        SymbolSvgItem.__init__(self, path, uid)

        self.setZValue(QEngineeringEquipmentItem.ZVALUE)

    '''

        @brief  connect attribute

        @author humkyung

        @date   2018.05.03

    '''

    def connectAttribute(self, attributes):

        from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

        self._texts.clear()

        """

        rect = self.sceneBoundingRect()

        attrs = [attr for attr in attributes if type(attr) is QEngineeringTagNoTextItem]

        # check if text locates inside equipment

        for attr in attrs:

            if rect.contains(attr.center()):

                self.attrs.append(attr)

                attrs.remove(attr)

                break

        if not self.attrs:

            minDist = None

            selected = None

            # get nearest text from equipment

            for attr in attrs:

                dx = attr.center().x() - rect.center().x()

                dy = attr.center().y() - rect.center().y()

                dist = math.sqrt(dx*dx + dy*dy)

                if (minDist is None) or (dist < minDist):

                    minDist = dist

                    selected = attr

            if selected is not None: self.attrs.append(selected)

        """

        try:

            rect = self.sceneBoundingRect()

            attrs = [attr for attr in attributes if type(attr) is QEngineeringTagNoTextItem]

            for attr in attrs:

                if rect.contains(attr.center()):

                    self._texts.append(attr)

            if not self._texts:

                minDist = None

                selected = None

                # get nearest text from equipment

                for attr in attrs:

                    dx = attr.center().x() - rect.center().x()

                    dy = attr.center().y() - rect.center().y()

                    dist = math.sqrt(dx*dx + dy*dy)

                    if (minDist is None) or (dist < minDist):

                        minDist = dist

                        selected = attr

                if selected is not None: self._texts.append(selected)

            self._texts = sorted(self._texts, key=lambda attr: attr.loc[1])    # sort by y coordinate

        except Exception as ex:

            from App import App 

            from AppDocData import MessageType

            message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)

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

    '''

        @brief      get attributes

        @author     humkyung

        @date       2018.06.14

    '''

    def getAttributes(self):

        _attrs = {}

        try:

            from AppDocData import AppDocData

            from EngineeringTextItem import QEngineeringTextItem

            # 해당 Type의 attribute setting

            docData = AppDocData.instance()

            symbolAttrs = docData.getSymbolAttribute(self.type)

            for attr in symbolAttrs:

                if attr.AttributeType == 'Text Item':

                    at = int(attr.AttrAt)

                    if len(self._texts) > at:

                        item = self._texts[at]

                        _attrs[attr] = eval(attr.Expression) if attr.Expression else ''

                    else:

                        _attrs[attr] = ''

                elif attr.AttributeType == 'Symbol Item':

                    at = int(attr.AttrAt)

                    if len(self._symbols) > at:

                        item = self._symbols[at]

                        _attrs[attr] = eval(attr.Expression) if attr.Expression else ''

                    else:

                        _attrs[attr] = ''

                else:

                    _attrs[attr] = ''#self.attrs[attr[1]] if attr[1] in self.attrs.keys() else ''

        except Exception as ex:

            from App import App 

            from AppDocData import MessageType

            message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)

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

        return _attrs

    '''

        @brief      generate xml code for equipment

        @author     humkyung

        @date       2018.05.09

    '''

    def toXml(self):

        from xml.etree.ElementTree import Element, SubElement, dump, ElementTree

        try:

            node = SymbolSvgItem.toXml(self)

            self.toXmlAsAttribute(node)

        except Exception as ex:

            print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))

        return node 

    '''

        @brief  generate xml code for attribute

        @author humkyung

        @date   2018.05.03

    '''

    def toXmlAsAttribute(self, parentNode):

        for attr in self._texts:

            parentNode.append(attr.toXml(self, None))

    def toSql(self):

        """

        convert equipment data to sql query

        """

        from AppDocData import AppDocData

        appDocData = AppDocData.instance()

        cols = ['UID', 'PNID_NO']

        values = ['?','?']

        param = [str(self.uid), appDocData.activeDrawing.name]

        _attrs = self.getAttributes()

        for key in _attrs.keys():

            cols.append(key.Attribute)

            values.append('?')

            param.append(_attrs[key])

        sql = 'insert or replace into EQUIPMENT_DATA_LIST({}) values({})'.format(','.join(cols), ','.join(values))

        return (sql, tuple(param))

    '''

        @brief      return equip Data List

        @author     kyouho

        @date       2018.08.14

    '''

    def getEquipmentDataList(self):

        dataList = []

        try:

            from AppDocData import AppDocData

            global equipColumnList

            docData = AppDocData.instance()

            attrs = self.attrs

            for index in range(len(equipColumnList)):

                dataList.append('')

            dataList[0] = str(self.uid)

            dataList[14] = docData.imgName

            for attr in attrs:

                attrInfo = docData.getSymbolAttributeByUID(attr.attribute)

                attrName = attrInfo[0]

                if equipColumnList.count(attrName):

                    colIndex = equipColumnList.index(attrName)

                    if type(attr) is UserInputAttribute:

                        dataList[colIndex] = attr.text if attr.text is not None else ''

                    elif type(attr) is QEngineeringTextItem:

                        dataList[colIndex] = attr.text()

                    else:

                        dataList[colIndex] = attr.uid

        except Exception as ex:

            print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))

        return dataList

    def __init__(self, uid=None, parent=None):

        QEngineeringTextItem.__init__(self, uid, parent)

    def setAttribute(self, key, value):

        matches = [attr for attr in self.attrs if attr.UID == key.UID]

            self.attrs[matches[0]] = value

        else:

            self.attrs[key] = value

        from SymbolAttr import SymbolAttr

        _attrs = {}

                attr = SymbolAttr()

                attr.Attribute = 'LINE NO'

                attr.DisplayAttribute = 'Line No'

                attr.AttributeType = 'String'

                _attrs[attr] = self.text()

                props = docData.getLineProperties()

                for prop in props:

                    if prop.UID in configs:

                            if prop.UID == configs[i]:

                                _attrs[prop] = result[i]

                    else:

                        matches = [attr for attr in self.attrs if attr.UID == prop.UID]

                        if len(matches) == 1:

                            _attrs[matches[0]] = self.attrs[matches[0]]

                        else:

                            _attrs[prop] = ''

#            attrs['CONN'] = self.conns[0].uid if self.conns else ''

        return _attrs

                attrNode = key.toXml()

                attrNode.text = str(self.attrs[key])

                node.append(attrNode) 

                    lineProp = docData.getLinePropertiesByUID(key.UID)

                        attrName = key.Attribute.upper().replace(' ','')

# coding: utf-8

import os.path

import copy

import sys

try:

    from PyQt5.QtCore import Qt, QPointF, QRectF, pyqtSignal, QT_VERSION_STR, QRect

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QBrush, QPen, QTransform, QFont

    from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog, QGraphicsItem, QAbstractGraphicsShapeItem, QGraphicsTextItem

except ImportError:

    try:

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

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImage, QPixmap, QPainterPath, QFileDialog, QFont

    except ImportError:

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

from EngineeringPolylineItem import QEngineeringPolylineItem

from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

import OcrResultDialog

from AppDocData import AppDocData

from EngineeringTextItem import QEngineeringTextItem

import re

noteColumnList = ['UID', 'NOTE_NO', 'DESCRIPTION', 'PNID_NO']

class QEngineeringNoteItem(QEngineeringTextItem):

    '''

        @history    2018.04.30  Jeongwoo    Signal Parameter Changed (QEngineeringTextItem → QGraphicsItem)

    '''

    #removed = pyqtSignal(QGraphicsItem)

    def __init__(self, parent=None):

        QEngineeringTextItem.__init__(self, parent)

        self.title = None

        self.conetents = None

    '''

        @brief      Find Note Contents by NOTE No.

        @author     Jeongwoo

        @date       2018.04.27

        @history    2018.04.27  Jeongwoo    Append Note contents to list

                                            else-statement changed, if text starts with new LineNo header, do break

                                            Moved from ResultTreeWidget

                    2018.05.02  Jeongwoo    Add if-statement. Append text to list when Regex start position is not 0

    '''

    def findNoteContents(self, noteNoText):

        # Get NoteArea

        notesArea = AppDocData.instance().getArea('Note')

        # Get all note contents

        items = self.scene().items(QRectF(notesArea.x, notesArea.y, notesArea.x + notesArea.width, notesArea.y + notesArea.height))

        items = [item for item in items if type(item) is QEngineeringTextItem] # Filtering QEngineeringTextItem

        items.sort(key=lambda item:item.loc[1]) # Compare with loc[1] (Y-Coord)

        foundNumberStr = None

        foundNote = []

        numberStr = ''

        results = re.findall("\d+", noteNoText)

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

            numberStr = results[0]

        for item in items:

            if type(item) is QEngineeringTextItem:

                text = item.text()

                if foundNumberStr is None: # Not found yet

                    try:

                        # Find NOTE Contents start with header [ex - 1. 1) 2. 2) ...]

                        position = re.search(numberStr+"(.|\))", text).start()

                        if position == 0: # Start with NOTE No.

                            foundNote.append(text)

                            foundNumberStr = numberStr

                    except Exception as ex:

                        '''NOT FOUND, DO NOTHING'''

                else:

                    try:

                        position = re.search("\d+(.|\))", text).start()

                        # If NOTE No starts with any number header, break

                        if position == 0:

                            break

                        else:

                            foundNote.append(text)

                    except Exception as ex:

                        foundNote.append(text)

        return foundNote

    def toSql(self):

        """

        convert note no data to sql query

        """

        from AppDocData import AppDocData

        appDocData = AppDocData.instance()

        cols = ['UID', 'NOTE_NO', 'DESCRIPTION', 'PNID_NO']

        values = ['?','?', '?', '?']

        noteContentsList = self.findNoteContents(self.text())

        param = [str(self.uid), ''.join(re.findall('\d*', self.text())), ' '.join(noteContentsList), appDocData.activeDrawing.name]

        sql = 'insert or replace into NOTE_DATA_LIST({}) values({})'.format(','.join(cols), ','.join(values))

        return (sql, tuple(param))

    '''

        @brief      return note Data List

        @author     kyouho

        @date       2018.10.10

    '''

    def getNoteDataList(self):

        dataList = []

        try:

            from AppDocData import AppDocData

            global noteColumnList

            docData = AppDocData.instance()

            noteContentsList = self.findNoteContents(self.text())

            loopIndex = 1

            for noteDescription in noteContentsList:

                data = []

                for index in range(len(noteColumnList)):

                    data.append('')

                data[0] = str(self.uid) + "-" + str(loopIndex)

                import re

                data[1] = ''.join(re.findall('\d*', self.text()))

                data[2] = noteDescription

                data[3] = docData.imgName

                dataList.append(data)

        except Exception as ex:

            print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))

        return dataList

        from EngineeringNoteItem import QEngineeringNoteItem

                self._texts.append(selected)

        from EngineeringEquipmentItem import QEngineeringEquipmentItem

  File "dist\SmartFEED\Shapes\EngineeringEquipmentItem.py"

  File "dist\SmartFEED\Shapes\EngineeringNoteItem.py"

  File "dist\SmartFEED\Shapes\__pycache__\EngineeringEquipmentItem.cpython-36.pyc"

  File "dist\SmartFEED\Shapes\__pycache__\EngineeringNoteItem.cpython-36.pyc"

  Delete "$INSTDIR\Shapes\__pycache__\EngineeringNoteItem.cpython-36.pyc"

  Delete "$INSTDIR\Shapes\__pycache__\EngineeringEquipmentItem.cpython-36.pyc"

  Delete "$INSTDIR\Shapes\EngineeringNoteItem.py"

  Delete "$INSTDIR\Shapes\EngineeringEquipmentItem.py"

        self.Length = None

    def toXml(self):

        """

        generate xml code for symbol attribute

        """

        from xml.etree.ElementTree import Element, SubElement, dump, ElementTree

        node = Element('ATTRIBUTE')

        node.attrib['UID'] = str(self.UID)

        node.attrib['Attribute'] = self.Attribute

        node.attrib['DisplayAttribute'] = self.DisplayAttribute

        node.attrib['AttributeType'] = self.AttributeType

        node.attrib['AttrAt'] = str(self.AttrAt)

        node.attrib['Expression'] = self.Expression

        node.attrib['Length'] = str(self.Length)

        return node

            if worker is not None: worker.updateProgress.emit(maxProgressValue, resultTextInfo[0].getText() if 1 == len(resultTextInfo) else None)

from EngineeringNoteItem import QEngineeringNoteItem

                item = QEngineeringLineNoTextItem()

    from EngineeringNoteItem import QEngineeringNoteItem