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'

    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.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):

        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)]

                        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)]

            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

        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)

            else:

                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:

            return matches[0].mainSize

        else:

            return None

    @property

    def EvaluatedSize(self):

        from EngineeringReducerItem import QEngineeringReducerItem

        from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

        from AppDocData import AppDocData

        try:

            if self.Size: 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: return item.mainSubSize[0]

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

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

                        else:

                            if item.Size: 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: return item.mainSubSize[0]

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

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

                        else:

                            if item.Size: return item.Size

                        prev = item

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

                        return None

                        #return AppDocData.instance().drain_size

                return self.owner.Size

            return 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)

            #App.mainWnd().addMessage.emit(MessageType.Error, str(self.uid) + self.name + message)

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

    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 None

    def EvaluatedDrawing(self, prop):

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

        from EngineeringTextItem import QEngineeringTextItem

        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()

    def EvaluatedAttribute(self, prop):

        """ return item's attribute """

        attrs = self.getAttributes()

        if attrs:

            for key, value in attrs.items():

                if key.Attribute == prop:

                    return value

        return ''

    def getAttributes(self, findOwner=False):

        """calculate all attributes of item"""

        import re

        if findOwner and self._skip:

            return self.attrs

        elif findOwner:

            self._skip = True

        else:

            self._skip = False

        _attrs = {}

        try:

            from AppDocData import AppDocData

            from SymbolSvgItem import SymbolSvgItem

            from EngineeringTextItem import QEngineeringTextItem

            from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

            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 = []

            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 is 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]

                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']:

                # 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] = eval(attr.Expression) if attr.Expression else ''

                    elif attr.AssocItem:

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

                        _attrs[attr] = eval(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] = eval(attr.Expression) if attr.Expression else ''

                    else:

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

                        _attrs[attr] = eval(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] = eval(attr.Expression) if attr.Expression else ''

                    elif attr.AssocItem:

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

                        _attrs[attr] = eval(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] = eval(attr.Expression) if attr.Expression else _attrs[attr]

            """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] = eval(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)

            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)]

                    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)]

                    if matches: self._properties[prop] = matches[0]

                if prop.Expression: self._properties[prop] = eval(prop.Expression)

        elif issubclass(type(self), SymbolSvgItem):

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

                try:

                    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)]

                        if matches: self._properties[prop] = matches[0]

                    if prop.Expression:

                        item = self._properties[prop]  # assign item

                        self._properties[prop] = eval(prop.Expression)

                except Exception as ex:

                    from App import App

                    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)

        elif type(self) is QEngineeringVendorItem:

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

                try:

                    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)]

                        if matches: self._properties[prop] = matches[0]

                    if prop.Expression:

                        item = self._properties[prop]  # assign item

                        self._properties[prop] = eval(prop.Expression)

                except Exception as ex:

                    from App import App

                    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 self._properties

    @properties.setter

    def properties(self, value):

        """ setter of properties """

        self._properties = value

    def prop(self, name):

        """ return property with given value """

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

        from EngineeringVendorItem import QEngineeringVendorItem

        if type(self) is QEngineeringLineNoTextItem:

            matches = [prop for prop, _ in self.properties.items() if prop.Attribute == name]

            return self.properties[matches[0]] if matches else None

        elif type(self) is QEngineeringLineItem:

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

            if matches: return matches[0][1]

            return None

        elif issubclass(type(self), SymbolSvgItem):

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

            if matches: return matches[0][1]

            return None

        elif type(self) is QEngineeringVendorItem:

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

            if matches: return matches[0][1]

    def set_property(self, property, value):

        """ set property with given value """

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

        from EngineeringVendorItem import QEngineeringVendorItem

        if type(self) is QEngineeringLineNoTextItem:

            matches = [prop for prop, _ in self._properties.items() if prop.Attribute == property]

            if matches: self._properties[matches[0]] = value

        elif type(self) is QEngineeringLineItem:

            if issubclass(type(value), QEngineeringAbstractItem): self.add_assoc_item(value, 0)

            matches = [prop for prop, _ in self._properties.items() if prop.Attribute == property]

            if matches: self._properties[matches[0]] = value

        elif issubclass(type(self), SymbolSvgItem):

            if issubclass(type(value), QEngineeringAbstractItem): self.add_assoc_item(value, 0)

            matches = [prop for prop, _ in self._properties.items() if prop.Attribute == property]

            if matches: self._properties[matches[0]] = value

        elif type(self) is QEngineeringVendorItem:

            if issubclass(type(value), QEngineeringAbstractItem):

                self.add_assoc_item(value, 0)

            matches = [prop for prop, _ in self._properties.items() if prop.Attribute == property]

            if matches: self._properties[matches[0]] = value

    def center(self):

        return self.sceneBoundingRect().center()

if __name__ == '__main__':

    import re

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

    value, pos = '', 0

    _attrs = {'a': '~', 'b': '!', 'C': '+'}

    expression = 'XXXXXXX{a}-{b}-{C}----'

    matches = p.finditer(expression)

    for match in matches:

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

        value += expression[pos:match.start()] + _attrs[attr_name]

        pos = match.end()

    value += expression[pos:len(expression)]

    print(value)