HYTOS

# coding: utf-8

""" This is engineering abstract item module """

import sys

#import random

class QEngineeringAbstractItem:

    '''

        @history    2018.05.15  Jeongwoo    Remove call super

                    2018.05.17  Jeongwoo    Add DEFAULT_COLOR Variable

    '''

    DEFAULT_COLOR = '#0000FF'

    HOVER_COLOR = '#BC4438'

    SELECTED_COLOR = '#FF00BF'

    CONNECTED_AT_PT = 0

    CONNECTED_AT_BODY = 1

    HOVER_ZVALUE = 200

    def __init__(self, parent=None):

        self._color = self.DEFAULT_COLOR  # default color

        self._owner = None

        self.conns = []

        self.special_item_type = None  # UID for special item type

        self._hover = False

        self._area = None

        self.connectors = []

        self.attrs = {}  # attributes

        self._associations = {'Text Item': [], 'Symbol Item': []}  # associated items

        self.sizeDepth = 0

        #self.refresh_count = random.randint(0, 9)

    @property

    def hover(self):

        """ return hover """

        return self._hover

    @hover.setter

    def hover(self, value):

        """ set hover """

        self._hover = value

    def change_color(self, value):

        """ change item's color """

        self._color = value

    def highlight(self, flag):

        pass

    '''

        @brief      Abstract method. Variable [color] is RGB hex code

        @author     Jeongwoo

        @date       2018.05.11

    '''

    def setColor(self, color):

        raise NotImplementedError

    '''

        @brief  return color

        @author Jeongwoo

        @date   2018.05.11

    '''

    def getColor(self):

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringEquipmentItem import QEngineeringEquipmentItem

        from EngineeringInstrumentItem import QEngineeringInstrumentItem

        from AppDocData import AppDocData

        from DisplayColors import DisplayColors

        from DisplayColors import DisplayOptions

        from EngineeringAbstractItem import QEngineeringAbstractItem

        from EngineeringLineItem import QEngineeringLineItem

        def check_stream_no_attribute():

            """ return stream no if item has stream no attribute else return False """

            _attrs = self.getAttributes(findOwner=True)

            for key, value in _attrs.items():

                if key.Attribute == 'Stream No':

                    if value:

                        return value

                    elif value == '' or value == None:

                        return None

                    else:

                        return False

        try:

            if DisplayOptions.DisplayByStreamNo == DisplayColors.instance().option and \

                    (issubclass(type(self), SymbolSvgItem) or type(self) is QEngineeringLineItem):

                app_doc_data = AppDocData.instance()

                res = check_stream_no_attribute()

                if res and res in app_doc_data._hmbColors:

                    return app_doc_data._hmbColors[res]

                else:

                    return QEngineeringAbstractItem.DEFAULT_COLOR

            if type(self) is QEngineeringEquipmentItem:

                # if DisplayOptions.DisplayByLineType == DisplayColors.instance().option:

                if self.hover:

                    return SymbolSvgItem.HOVER_COLOR

                elif not QEngineeringEquipmentItem.EQUIP_COLOR:

                    app_doc_data = AppDocData.instance()

                    configs = app_doc_data.getConfigs('Equipment', 'Color')

                    QEngineeringEquipmentItem.EQUIP_COLOR = configs[

                        0].value if configs else QEngineeringAbstractItem.DEFAULT_COLOR

                return QEngineeringEquipmentItem.EQUIP_COLOR

            elif type(self) is QEngineeringInstrumentItem:

                if self.hover:

                        return SymbolSvgItem.HOVER_COLOR

                elif DisplayOptions.DisplayByLineType == DisplayColors.instance().option:

                    if not QEngineeringInstrumentItem.INST_COLOR:

                        app_doc_data = AppDocData.instance()

                        configs = app_doc_data.getConfigs('Instrument', 'Color')

                        QEngineeringInstrumentItem.INST_COLOR = configs[

                            0].value if configs else QEngineeringAbstractItem.DEFAULT_COLOR

                    return QEngineeringInstrumentItem.INST_COLOR

                else:

                    return self.owner._color if self.owner and hasattr(self.owner, '_color') else self._color

            elif type(self) is SymbolSvgItem:

                return SymbolSvgItem.HOVER_COLOR if self.hover else ( \

                    self.owner._color if self.owner and hasattr(self.owner, '_color') else self._color)

            elif type(self) is QEngineeringLineItem:

                if self.hover:

                    return QEngineeringAbstractItem.HOVER_COLOR

                elif self.isSelected():

                    return QEngineeringAbstractItem.SELECTED_COLOR

                elif DisplayOptions.DisplayByLineType == DisplayColors.instance().option:

                    if self.lineType in QEngineeringLineItem.LINE_TYPE_COLORS:

                        return QEngineeringLineItem.LINE_TYPE_COLORS[self.lineType]

                    else:

                        app_doc_data = AppDocData.instance()

                        configs = app_doc_data.getConfigs('LineTypes', self.lineType)

                        if configs:

                            tokens = configs[0].value.split(',')

                            QEngineeringLineItem.LINE_TYPE_COLORS[self.lineType] = tokens[0] if len(tokens) == 4 else \

                                QEngineeringAbstractItem.DEFAULT_COLOR

                            return QEngineeringLineItem.LINE_TYPE_COLORS[self.lineType]

                        else:

                            return QEngineeringAbstractItem.DEFAULT_COLOR

                else:

                    return self.owner._color if self.owner and hasattr(self.owner, '_color') else self._color

                    '''

                    if self.owner is None:

                        return self._color

                    else:

                        return self.owner.getColor()

                    '''

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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  QEngineeringAbstractItem.DEFAULT_COLOR

        return QEngineeringAbstractItem.HOVER_COLOR if self.hover else (

            self.owner.getColor() if (self.owner and hasattr(self.owner, '_color')) else self._color)

    '''

        @brief  getter of owner

        @author humkyung

        @date   2018.05.12

    '''

    @property

    def owner(self):

        return self._owner

    '''

        @brief  setter of owner

        @author humkyung

        @date   2018.05.12

    '''

    @owner.setter

    def owner(self, value):

        self._owner = value

    @property

    def has_connection(self):

        """ check this is connected to other """

        for connector in self.connectors:

            if connector.connectedItem: return True

        return False

    def validate(self):

        """ validate this """

        raise NotImplementedError('To be implemented')

    '''

        @brief  getter of area

        @author humkyung

        @date   2018.09.06

    '''

    @property

    def area(self):

        return self._area if self._area is not None else 'None'

    '''

        @brief  setter of area

        @author humkyung

        @date   2018.09.06

    '''

    @area.setter

    def area(self, value):

        self._area = value

    '''

        @brief  write to xml

        @author humkyung

        @date   2018.05.16

    '''

    def toXml(self):

        pass

    def to_svg(self, parent=None) -> list:

        pass

    '''

        @brief  write attribute to xml

        @author humkyung

        @date   2018.05.16

    '''

    def toXmlAsAttribute(self, parent):

        pass

    def toSql(self):

        """convert to sql query"""

        pass

    def isOverlap(self, rect1, rect2):

        """

        @brief  return true if rects have intersection, rect is QRect

        @author euisung

        @date   2019.09.02

        """

        lt1, rb1 = (rect1.left(), rect1.top()), (rect1.right(), rect1.bottom())

        lt2, tb2 = (rect2.left(), rect2.top()), (rect2.right(), rect2.bottom())

        if rect1.left() > rect2.right() or rect2.left() > rect1.right():

            return False

        if rect1.bottom() < rect2.top() or rect2.bottom() < rect1.top():

            return False

        return True

    def associations(self):

        """ return associated instance """

        # move to abstractitem

        import uuid

        try:

            res = []

            for key in self._associations.keys():

                index = 0

                for assoc in list(self._associations[key]):

                    # find owner with uid if self.scene() is valid

                    if self.scene() and assoc and type(assoc) is uuid.UUID:

                        #matches = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(assoc)]

                        matches = []

                        for item in self.scene().items():

                            if hasattr(item, 'uid') and str(item.uid) == str(assoc):

                                matches = [item]

                                break

                        if matches:

                            res.append(matches[0])

                            self._associations[key][index] = matches[0]

                    # up to here

                    elif assoc:

                        res.append(assoc)

                    index += 1

            for key in self.attrs.keys():

                if type(key.AssocItem) is uuid.UUID:

                    for assoc in res:

                        if str(key.AssocItem) == str(assoc.uid):

                            key.AssocItem = assoc

            return res

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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 []

    def get_assoc_item(self, assoc):

        """ get associated item of given object """

        import uuid

        if assoc and type(assoc) is uuid.UUID:

            #matches = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(assoc)]

            matches = []

            for item in self.scene().items():

                if hasattr(item, 'uid') and str(item.uid) == str(assoc):

                    matches = [item]

                    break

            if matches:

                return matches[0]

        return assoc

    def texts(self):

        """ return text type of associations """

        res = []

        for text in self.texts_order():

            consumed = False

            for key in list(self.attrs.keys()):

                if key.AssocItem and key.AssocItem is text:

                    consumed = True

            if not consumed:

                res.append(text)

        return res

    def texts_order(self):

        from EngineeringTextItem import QEngineeringTextItem

        return sorted([x for x in self.associations() if issubclass(type(x), QEngineeringTextItem)],

                           key=lambda attr: attr.loc[1])

    def symbols(self, symbol_attr_number):

        """ return symbol type of associations """

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringVendorItem import QEngineeringVendorItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

        res = []

        for symbol in [x for x in self.associations() if

                       issubclass(type(x), SymbolSvgItem) or type(x) is QEngineeringVendorItem or type(x) is QEngineeringLineItem]:

            if symbol_attr_number > 1:

                consumed = False

                for key in list(self.attrs.keys()):

                    if key.AssocItem and key.AssocItem is symbol:

                        consumed = True

                if not consumed:

                    res.append(symbol)

            elif type(self) is not QEngineeringLineNoTextItem:

                res.append(symbol)

        return res

    @property

    def Size(self):

        """ return symbol's size """

        from QEngineeringSizeTextItem import QEngineeringSizeTextItem

        matches = [assoc for assoc in self.associations() if type(assoc) is QEngineeringSizeTextItem]

        if matches:

            attrs = [attr for attr in self.getTargetAttributes() if attr.AttributeType == 'Size Text Item']

            if attrs:

                return matches[0].mainSize

        return None

    @property

    def EvaluatedSize(self):

        from EngineeringReducerItem import QEngineeringReducerItem

        from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringInstrumentItem import QEngineeringInstrumentItem

        from AppDocData import AppDocData

        try:

            if self.Size:

                self.sizeDepth = 0

                return self.Size

            if self.owner and issubclass(type(self.owner), QEngineeringLineNoTextItem):

                matches = [run for run in self.owner.runs if self in run.items]

                if matches:

                    at = matches[0].items.index(self)

                    upstream = matches[0].items[:at]

                    upstream.reverse()

                    prev = self

                    for item in upstream:

                        if type(item) is QEngineeringReducerItem:

                            if item.connectors[0].connectedItem is prev:  ### Main Size

                                if item.mainSubSize and item.mainSubSize[0]:

                                    self.sizeDepth = 0

                                    return item.mainSubSize[0]

                            elif item.connectors[1].connectedItem is prev:  ### Sub Size

                                if item.mainSubSize and item.mainSubSize[1]:

                                    self.sizeDepth = 0

                                    return item.mainSubSize[1]

                        elif type(item) is QEngineeringInstrumentItem and item.iType == 22: # Relief Valve -> upstream always false

                            if item.mainSubSize and item.mainSubSize[0]:

                                self.sizeDepth = 0

                                return item.mainSubSize[0]

                        else:

                            if item.Size:

                                self.sizeDepth = 0

                                return item.Size

                        prev = item

                    downstream = matches[0].items[at:]

                    prev = self

                    for item in downstream:

                        if type(item) is QEngineeringReducerItem:

                            if item.connectors[0].connectedItem is prev:  ### Main Size

                                if item.mainSubSize and item.mainSubSize[0]:

                                    self.sizeDepth = 0

                                    return item.mainSubSize[0]

                            elif item.connectors[1].connectedItem is prev:  ### Sub Size

                                if item.mainSubSize and item.mainSubSize[1]:

                                    self.sizeDepth = 0

                                    return item.mainSubSize[1]

                        elif type(item) is QEngineeringInstrumentItem and item.iType == 22: # Relief Valve

                            if item.mainSubSize and item.mainSubSize[1]:

                                self.sizeDepth = 0

                                return item.mainSubSize[1]

                        else:

                            if item.Size:

                                self.sizeDepth = 0

                                return item.Size

                        prev = item

                    #if 'Drain' == matches[0].Type:

                    #    self.sizeDepth = 0

                    #    return ''

                    #    #return AppDocData.instance().drain_size

                if self.owner.runs and self in self.owner.runs[0].items:

                    self.sizeDepth = 0

                    return self.owner.Size 

                elif self.sizeDepth < 2:

                    matches = [run for run in self.owner.runs if self in run.items]

                    if matches:

                        if type(matches[0].items[0]) is QEngineeringLineItem:

                            _item = matches[0].items[0]

                            connectedItems = [conn.connectedItem for conn in _item.connectors if conn._connected_at == QEngineeringAbstractItem.CONNECTED_AT_PT and \

                                                                                                            conn.connectedItem and conn.connectedItem not in matches[0].items]

                            if connectedItems:

                                connectedItems[0].sizeDepth = self.sizeDepth + 1

                                res  = connectedItems[0].EvaluatedSize

                                if res:

                                    self.sizeDepth = 0

                                    return res

                        if type(matches[0].items[-1]) is QEngineeringLineItem:

                            _item = matches[0].items[-1]

                            connectedItems = [conn.connectedItem for conn in _item.connectors if conn._connected_at == QEngineeringAbstractItem.CONNECTED_AT_PT and \

                                                                                                            conn.connectedItem and conn.connectedItem not in matches[0].items]

                            if connectedItems:

                                connectedItems[0].sizeDepth = self.sizeDepth + 1

                                res  = connectedItems[0].EvaluatedSize

                                if res:

                                    self.sizeDepth = 0

                                    return res

                        if issubclass(type(matches[0].items[0]), SymbolSvgItem):

                            _item = matches[0].items[0]

                            connectedItems = [_item.connectors[index].connectedItem for index in range(len(_item.conn_type)) if (_item.conn_type[index] == 'Secondary' or _item.conn_type[index] == 'Primary') and \

                                                                                                            _item.connectors[index].connectedItem and _item.connectors[index].connectedItem not in matches[0].items]

                            if connectedItems:

                                connectedItems[0].sizeDepth = self.sizeDepth + 1

                                res  = connectedItems[0].EvaluatedSize

                                if res:

                                    self.sizeDepth = 0

                                    return res

                        if issubclass(type(matches[0].items[-1]), SymbolSvgItem):

                            _item = matches[0].items[-1]

                            connectedItems = [_item.connectors[index].connectedItem for index in range(len(_item.conn_type)) if (_item.conn_type[index] == 'Secondary' or _item.conn_type[index] == 'Primary') and \

                                                                                                            _item.connectors[index].connectedItem and _item.connectors[index].connectedItem not in matches[0].items]

                            if connectedItems:

                                connectedItems[0].sizeDepth = self.sizeDepth + 1

                                res  = connectedItems[0].EvaluatedSize

                                if res:

                                    self.sizeDepth = 0

                                    return res

                        '''

                        if type(matches[0].items[0]) is QEngineeringLineItem and type(matches[0].items[-1]) is QEngineeringLineItem:

                            res1 = None

                            res2 = None

                            _item = matches[0].items[0]

                            connectedItems = [conn.connectedItem for conn in _item.connectors if conn.connectedItem and conn.connectedItem not in matches[0].items]

                            if connectedItems:

                                connectedItems[0].sizeDepth = self.sizeDepth + 1

                                res1  = connectedItems[0].EvaluatedSize

                            _item = matches[0].items[-1]

                            connectedItems = [conn.connectedItem for conn in _item.connectors if conn.connectedItem and conn.connectedItem not in matches[0].items]

                            connectedItems.reverse()

                            if connectedItems:

                                connectedItems[0].sizeDepth = self.sizeDepth + 1

                                res2  = connectedItems[0].EvaluatedSize

                                if res1 and res2:

                                    self.sizeDepth = 0

                                    return res1 if self.inch_to_number(res1) <= self.inch_to_number(res2) else res2

                        '''

                        if type(matches[0].items[0]) is QEngineeringLineItem:

                            _item = matches[0].items[0]

                            connectedItems = [conn.connectedItem for conn in _item.connectors if conn.connectedItem and conn.connectedItem not in matches[0].items]

                            if connectedItems:

                                connectedItems[0].sizeDepth = self.sizeDepth + 1

                                res  = connectedItems[0].EvaluatedSize

                                if res:

                                    self.sizeDepth = 0

                                    return res

                        if type(matches[0].items[-1]) is QEngineeringLineItem:

                            _item = matches[0].items[-1]

                            connectedItems = [conn.connectedItem for conn in _item.connectors if conn.connectedItem and conn.connectedItem not in matches[0].items]

                            if connectedItems:

                                connectedItems[0].sizeDepth = self.sizeDepth + 1

                                res  = connectedItems[0].EvaluatedSize

                                if res:

                                    self.sizeDepth = 0

                                    return res

            self.sizeDepth = 0

            return ''

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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, str(self.uid) + self.name + message)

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

            return ''

    def EvaluatedTable(self, old_code, table_name):

        """ return new attribute code """

        from AppDocData import AppDocData

        from CodeTables import CodeTable

        try:

            found = CodeTable.instance(table_name).find_match_exactly(old_code)

            return found if found else ''

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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)

    def EvaluatedLineNo(self, prop):

        """ return line no attr """

        from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

        if self.owner and type(self.owner) is QEngineeringLineNoTextItem:

            attrs = self.owner.getAttributes()

            for attr, value in attrs.items():

                if prop == attr.Attribute:

                    return value

        return ''

    def EvaluatedDrawing(self, prop=None):

        """ return text item that is in prop"""

        from EngineeringTextItem import QEngineeringTextItem

        from AppDocData import AppDocData

        if prop is not None:

            scene = self.scene()

            if scene:

                items = [item for item in scene.items() if issubclass(type(item), QEngineeringTextItem) and item.area == prop]

                if items:

                    return items[0]

            return QEngineeringTextItem()

        else:

            app_doc_data = AppDocData.instance()

            drawing_name = app_doc_data.activeDrawing.name

            drawing_text_item = QEngineeringTextItem()

            drawing_text_item.setPlainText(drawing_name)

            return drawing_text_item

    def EvaluatedLabel(self, prop):

        """ return label symbol's attribute """

        from SymbolSvgItem import SymbolSvgItem

        scene = self.scene()

        if not scene:

            return ''

        labels = [item for item in scene.items() if issubclass(type(item), SymbolSvgItem) and (item.iType == 19 or item.iType == 29 or item.iType == 30)]

        if labels:

            labels = [label for label in labels if label.EvaluatedAttribute('OWNERSYMBOL') == self]

            if labels and len(labels) == 1:

                return labels[0].EvaluatedAttribute(prop)

            else:

                for label in labels:

                    value = label.EvaluatedAttribute(prop)

                    if value and value != 'None':

                        return value

        return ''

    def EvaluatedAttribute(self, prop, cache=False):

        """ return item's attribute """

        attrs = self.getAttributes(findOwner=cache)

        if attrs:

            for key, value in attrs.items():

                if key.Attribute == prop:

                    return value

        return ''

    @property

    def stream_no(self):

        matches = [attr for attr in self.attrs if attr.Attribute.upper() == 'STREAM NO']

        if matches:

            return self.attrs[matches[0]]

        return ''

    @property

    def case(self):

        matches = [attr for attr in self.attrs if attr.Attribute.upper() == 'CASE']

        if matches:

            return self.attrs[matches[0]]

        return ''

    '''

    @stream_no.setter

    def stream_no(self, value):

        from AppDocData import AppDocData

        matches = [attr for attr in self.attrs if attr.Attribute.upper() == 'STREAM NO']

        if matches:

            self.attrs[matches[0]] = value

            """reset attributes for hmb with given stream no"""

            app_doc_data = AppDocData.instance()

            stream_data = app_doc_data.hmbTable.dataOfStreamNo(value)

            for attr in self.attrs:

                if attr.AttributeType == 'HMB':

                    matches = [data for data in stream_data if data.name == attr.Attribute]

                    if matches:

                        self.attrs[attr] = matches[0].value

                    else:

                        self.attrs[attr] = ''

    '''

    def try_eval(self, item, expression):

        try:

            return eval(expression)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

                                                           sys.exc_info()[-1].tb_lineno) + ' Item UID : ' + str(self.uid)

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

        return ''

    def getTargetAttributes(self):

        """get target attributes"""

        from AppDocData import AppDocData

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringVendorItem import QEngineeringVendorItem

        from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

        from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

        from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

        """ get attributes of item from database """

        app_doc_data = AppDocData.instance()

        if type(self) is QEngineeringLineItem:

            symbolAttrs = app_doc_data.getSymbolAttribute('Line')

        elif type(self) is QEngineeringVendorItem:

            symbolAttrs = app_doc_data.getSymbolAttribute('Package')

        elif type(self) is QEngineeringLineNoTextItem:

            symbolAttrs = app_doc_data.getSymbolAttribute('Line No')

            self.getLineNoAttributes(_attrs)

        elif type(self) is QEngineeringTagNoTextItem:

            self.getTagNoAttributes(_attrs)

            self.attrs = _attrs

            return self.attrs

        else:

            symbolAttrs = app_doc_data.getSymbolAttribute(self.type)

        targetAttrs = []

        if not (type(self) is QEngineeringLineItem or type(self) is QEngineeringVendorItem or

                type(self) is QEngineeringLineNoTextItem or type(self) is QEngineeringTagNoTextItem):

            for attr in symbolAttrs:

                if not attr.Target and not type(self) is QEngineeringSpecBreakItem:

                    continue

                if attr.Target is None or attr.Target == 'ALL' or \

                        type(self) is QEngineeringSpecBreakItem or \

                            [target for target in attr.Target.split(',') if self.dbUid == int(target)]:

                    targetAttrs.append(attr)

        else:

            targetAttrs = symbolAttrs

        return targetAttrs

    def getAttributes(self, findOwner=False):

        """calculate all attributes of item"""

        import re

        if findOwner and not hasattr(self, '_skip'):

            self._skip = False

        elif findOwner and self._skip:

            return self.attrs

        elif findOwner:

            self._skip = True

        else:

            self._skip = False

        _attrs = {}

        try:

            from AppDocData import AppDocData

            from EngineeringLineItem import QEngineeringLineItem

            from EngineeringVendorItem import QEngineeringVendorItem

            from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

            from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

            from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

            from ItemDataExportDialog import QItemDataExportDialog

            """ get attributes of item from database """

            app_doc_data = AppDocData.instance()

            if type(self) is QEngineeringLineItem:

                symbolAttrs = app_doc_data.getSymbolAttribute('Line')

            elif type(self) is QEngineeringVendorItem:

                symbolAttrs = app_doc_data.getSymbolAttribute('Package')

            elif type(self) is QEngineeringLineNoTextItem:

                symbolAttrs = app_doc_data.getSymbolAttribute('Line No')

                self.getLineNoAttributes(_attrs)

            elif type(self) is QEngineeringTagNoTextItem:

                self.getTagNoAttributes(_attrs)

                self.attrs = _attrs

                return self.attrs

            else:

                symbolAttrs = app_doc_data.getSymbolAttribute(self.type)

            targetAttrs = []

            symbol_attr_number = 0

            if not (type(self) is QEngineeringLineItem or type(self) is QEngineeringVendorItem or

                    type(self) is QEngineeringLineNoTextItem or type(self) is QEngineeringTagNoTextItem):

                for attr in symbolAttrs:

                    if not attr.Target and not type(self) is QEngineeringSpecBreakItem:

                        continue

                    if attr.Target is None or attr.Target == 'ALL' or \

                            type(self) is QEngineeringSpecBreakItem or \

                                [target for target in attr.Target.split(',') if self.dbUid == int(target)]:

                        targetAttrs.append(attr)

                        if attr.AttributeType == 'Symbol Item' or attr.AttributeType == 'Line Item' or attr.AttributeType == 'EQ Item' or attr.AttributeType == 'Comp Item':

                            symbol_attr_number = max(symbol_attr_number, int(attr.AttrAt))

            else:

                targetAttrs = symbolAttrs

            _texts = self.texts()

            _symbols = self.symbols(symbol_attr_number + 1)

            # copy old values

            for attr in targetAttrs:

                #matches = [_attr for _attr, _ in self.attrs.items() if _attr.UID == attr.UID]

                matches = []

                for _attr, _ in self.attrs.items():

                    if _attr.UID == attr.UID:

                        matches = [_attr]

                        break

                if matches:

                    if matches[0].AttributeType == 'Spec' and not self.attrs[matches[0]]:

                        continue

                    attr.Freeze = matches[0].Freeze  # update freeze value

                    attr.AssocItem = matches[0].AssocItem

                    _attrs[attr] = self.attrs[matches[0]]  # copy attribute value

                else:

                    if attr.AttributeType != 'Spec':

                        _attrs[attr] = ''

            self.attrs = _attrs

            for attr in [_attr for _attr in sorted(self.attrs.keys(), key=lambda param:int(param.Index)) \

                            if _attr.AttributeType != 'Combined' and _attr.AttributeType != 'Reference' and _attr.AttributeType != 'HMB']:

                # if attr.Freeze: continue    # do not evaluate value if attribute is frozen

                if attr.AttributeType == 'Text Item' or attr.AttributeType == 'Valve Oper Code':

                    at = int(attr.AttrAt)

                    # Text Item can contain Valve Oper Code

                    if attr.AttributeType == 'Text Item':

                        items = _texts

                    else:

                        items = [text for text in _texts if

                                 QEngineeringAbstractItem.assoc_type(text) == attr.AttributeType]

                    if not attr.AssocItem and len(items) > at and not attr.Codes.values:

                        attr.AssocItem = items[at]

                        item = attr.AssocItem

                        _attrs[attr] = self.try_eval(item, attr.Expression) if attr.Expression else ''

                    elif attr.AssocItem:

                        item = attr.AssocItem = self.get_assoc_item(attr.AssocItem)

                        _attrs[attr] = self.try_eval(item, attr.Expression) if attr.Expression else ''

                    else:

                        _attrs[attr] = ''

                elif attr.AttributeType == 'Size Text Item' or attr.AttributeType == 'Tag No':

                    at = int(attr.AttrAt)

                    items = [text for text in _texts if QEngineeringAbstractItem.assoc_type(text) == attr.AttributeType]

                    if not attr.AssocItem and len(items) > at:

                        attr.AssocItem = items[at]

                        item = attr.AssocItem

                        _attrs[attr] = self.try_eval(item, attr.Expression) if attr.Expression else ''

                    else:

                        item = attr.AssocItem = self.get_assoc_item(attr.AssocItem)

                        _attrs[attr] = self.try_eval(item, attr.Expression) if attr.Expression and (

                                (item and 'item' in attr.Expression) or 'self' in attr.Expression) else ''

                elif attr.AttributeType == 'Symbol Item' or attr.AttributeType == 'Line Item' or \

                        attr.AttributeType == 'Comp Item' or attr.AttributeType == 'EQ Item':

                    at = int(attr.AttrAt)

                    if not attr.AssocItem and len(_symbols) > at:

                        attr.AssocItem = _symbols[at]

                        item = attr.AssocItem

                        _attrs[attr] = self.try_eval(item, attr.Expression) if attr.Expression else ''

                    elif attr.AssocItem:

                        item = attr.AssocItem = self.get_assoc_item(attr.AssocItem)

                        _attrs[attr] = self.try_eval(item, attr.Expression) if attr.Expression else ''

                    else:

                        _attrs[attr] = ''

                elif attr.AttributeType == 'String':

                    #_attrs[attr] = attr.Expression if attr.Expression and not _attrs[attr] else _attrs[attr]

                    _attrs[attr] = self.try_eval(None, attr.Expression) if attr.Expression else _attrs[attr]

            """calculate attribute value for HMB type"""

            configs = app_doc_data.getConfigs('Line List', 'Use Stream No')

            if configs and int(configs[0].value) == 1:

                matches = [_attr for _attr in _attrs if _attr.Attribute.upper() == 'STREAM NO']

                matches_case = [_attr for _attr in _attrs if _attr.Attribute.upper() == 'CASE']

                hmb_attrs = [_attr for _attr in targetAttrs if _attr.AttributeType == 'HMB']

                hmb_datas = app_doc_data.get_hmb_data(None) if hmb_attrs else None

                if hmb_datas and hmb_attrs and matches and _attrs[matches[0]] and _attrs[matches[0]] != 'None':

                    stream_no = _attrs[matches[0]]

                    names = []

                    for data in hmb_datas[0].datas[0]:

                        if data.name not in names:

                            names.append(data.name)

                    matches = [hmb_data for hmb_data in hmb_datas if hmb_data.stream_no == stream_no]

                    if matches:

                        data = {}

                        if matches_case:

                            data['Case'] = _attrs[matches_case[0]]

                        hmb_data = matches[0]

                        data = QItemDataExportDialog.make_hmb_data(data, hmb_data, names)

                        for _attr in hmb_attrs:

                            if _attr.Attribute in data:

                                _attrs[_attr] = data[_attr.Attribute]

                            else:

                                _attrs[_attr] = ''

            """up to here"""

            """calculate attribute value for combined type"""

            p = re.compile('{[A-Za-z0-9_ ]+}')

            for attr in [_attr for _attr in targetAttrs if _attr.AttributeType == 'Combined']:

                value, pos = '', 0

                matches = p.finditer(attr.Expression)

                for match in matches:

                    attr_name = attr.Expression[(match.start() + 1):(match.end() - 1)]

                    values = [value for key, value in _attrs.items() if key.Attribute == attr_name]

                    if not values:

                        values = [""]

                    value += attr.Expression[pos:match.start()] + values[0]

                    pos = match.end()

                value += attr.Expression[pos:len(attr.Expression)]

                _attrs[attr] = value

            """up to here"""

            """calculate attribute value for Reference type"""

            for attr in [_attr for _attr in targetAttrs if _attr.AttributeType == 'Reference']:

                value, pos = '', 0

                matches = p.finditer(attr.Expression)

                for match in matches:

                    attr_name = attr.Expression[(match.start() + 1):(match.end() - 1)]

                    values = [value for key, value in _attrs.items() if key.Attribute == attr_name]

                    if not values:

                        values = []

                    value += attr.Expression[pos:match.start()] + '\'' + values[0] + '\''

                    pos = match.end()

                value += attr.Expression[pos:len(attr.Expression)]

                _attrs[attr] = self.try_eval(None, value) if attr.Expression else ''

            """up to here"""

            for _attr, _value in _attrs.items():

                if _value is None or _value == '':

                    _attr.AssocItem = None

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

                                                           sys.exc_info()[-1].tb_lineno) + ' Item UID : ' + str(self.uid)

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

        return self.attrs

    def attrib(self, name):

        """ return the value of given attribute with name """

        matches = [(attr, value) for attr, value in self.getAttributes().items() if attr.Attribute == name]

        if matches: return matches[0][1]

        return None

    def set_attrib(self, attrib, value):

        """ set attribute with given value """

        matches = [attr for attr, _ in self.attrs.items() if attr.UID == attrib.UID]

        if len(matches) == 1: self.attrs[matches[0]] = value

    @staticmethod

    def assoc_type(item):

        """ return association type of given item """

        from EngineeringTextItem import QEngineeringTextItem

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

        from QEngineeringSizeTextItem import QEngineeringSizeTextItem

        from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringEquipmentItem import QEngineeringEquipmentItem

        from EngineeringVendorItem import QEngineeringVendorItem

        _type = None

        if type(item) is QEngineeringSizeTextItem:

            _type = 'Size Text Item'

        elif type(item) is QEngineeringValveOperCodeTextItem:

            _type = 'Valve Oper Code'

        elif type(item) is QEngineeringTagNoTextItem:

            _type = 'Tag No'

        elif type(item) is QEngineeringTextItem or issubclass(type(item), QEngineeringTextItem):

            _type = 'Text Item'

        elif type(item) is QEngineeringEquipmentItem or type(item) is QEngineeringVendorItem:

            _type = 'EQ Item'

        elif type(item) is SymbolSvgItem or issubclass(type(item), SymbolSvgItem):

            _type = 'Symbol Item'

        elif type(item) is QEngineeringLineItem:

            _type = 'Line Item'

        elif issubclass(type(item), SymbolSvgItem) or type(item) is QEngineeringLineItem:

            _type = 'Comp Item'

        return _type

    def clear_attr_and_assoc_item(self, force=False):

        """ clear attrs, return true if clear attrs """

        if force:

            self.attrs.clear()

            self._associations.clear()

            return True

        else:

            freeze = False

            for key in self.attrs.keys():

                if key.Freeze:

                    freeze = True

                    break

            if freeze:

                return False

            else:

                self.attrs.clear()

                self._associations.clear()

                return True

    def add_assoc_item(self, item, at=None, force=False):

        """ add given item to association """

        from EngineeringTextItem import QEngineeringTextItem

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

        from QEngineeringSizeTextItem import QEngineeringSizeTextItem

        if not force:

            for key in self.attrs.keys():

                if key.Freeze:

                    return False

        _type = QEngineeringAbstractItem.assoc_type(item)

        if _type is not None:

            if not _type in self._associations:

                self._associations[_type] = []

            if item in self._associations[_type]: return True

            if at is None:

                self._associations[_type].append(item)

            else:

                while len(self._associations[_type]) <= at: self._associations[_type].append(None)

                # if len(self._associations[_type]) > at and self._associations[_type][at] is not None:

                #    self._associations[_type][at].owner = None

                self._associations[_type][at] = item

            return True

        return False

    def remove_assoc_item(self, item):

        """ remove given item from association """

        _type = QEngineeringAbstractItem.assoc_type(item)

        if _type is not None:

            if _type in self._associations and item in self._associations[_type]:

                index = self._associations[_type].index(item)

                self._associations[_type].pop(index)

    @property

    def properties(self):

        """ getter of properties """

        import uuid

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

        from EngineeringVendorItem import QEngineeringVendorItem

        if type(self) is QEngineeringLineNoTextItem:

            for prop, value in self._properties.items():

                if prop.is_selectable and type(value) is uuid.UUID and self.scene():

                    #matches = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(value)]

                    matches = []

                    for item in self.scene().items():

                        if hasattr(item, 'uid') and str(item.uid) == str(value):

                            matches = [item]

                            break

                    if matches:

                        self._properties[prop] = matches[0]

        elif type(self) is QEngineeringLineItem:

            for prop, value in self._properties.items():

                if prop.is_selectable and type(value) is uuid.UUID and self.scene():

                    #matches = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(value)]

                    matches = []

                    for item in self.scene().items():

                        if hasattr(item, 'uid') and str(item.uid) == str(value):