HYTOS

        """calculate all attributes of item"""

        import re

            app_doc_data = AppDocData.instance()

                symbolAttrs = app_doc_data.getSymbolAttribute('Line')

                symbolAttrs = app_doc_data.getSymbolAttribute('Package')

                symbolAttrs = app_doc_data.getSymbolAttribute('Line No')

                symbolAttrs = app_doc_data.getSymbolAttribute(self.type)

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

                    type(self) is QEngineeringLineNoTextItem):

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

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

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

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

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

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

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

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

                    pos = match.end()

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

                _attrs[attr] = value

            """up to here"""

            for _attr, _value in _attrs.items():

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

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

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)

        self.Length = Length

        self.Expression = Expression

        return (self.AttributeType in [key for key, value in QSymbolAttrEditorDialog.SYMBOL_ATTR_DATA_TYPES.items() if

                                       value == -1])

            uuid_obj = uuid.UUID(value)  # , version=version)

        return str(uuid_obj) == value

        attr.AssocItem = uuid.UUID(record['Association_UID']) if record['Association_UID'] and record[

            'Association_UID'] != 'None' else None

        attr.AssocItem = uuid.UUID(node.attrib['AssocItem']) if 'AssocItem' in node.attrib and node.attrib[

            'AssocItem'] != '' else None

        return node

class AttributeDelegate(QStyledItemDelegate):

    def createEditor(self, parent, option, index):

        editor = super(AttributeDelegate, self).createEditor(parent, option, index)

        if index.column() == 1:

            editor = QLineEdit(parent)

            validator = QRegExpValidator(QRegExp('^[A-Za-z0-9]+$'), parent)

            editor.setValidator(validator)

        elif index.column() == 4:

            editor = QLineEdit(parent)

            validator = QRegExpValidator(QRegExp('^(\\d+|)$'), parent)

            editor.setValidator(validator)

        return editor

    """

    def setEditorData(self, editor, index):

        if index.column() == 4:

            m = 0 if index.column() == 1 else index.sibling(index.row(), 1).data()

            M = index.sibling(index.row(), 2).data() if index.column() == 1 else 360

            if hasattr(m, 'toPyObject'):

                m = m.toPyObject()

            if hasattr(M, 'toPyObject'):

                M = M.toPyObject()

            editor.setMinimum(m)

            editor.setMaximum(M)

        super(LimistDelegate, self).setEditorData(editor, index)

    """

                              'String': 1, 'Combined': 1}

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

            delegate = AttributeDelegate(self.ui.tableWidgetAttr)

            self.ui.tableWidgetAttr.setItemDelegate(delegate)

        if hasattr(self.ui.tableWidgetAttr.item(row, 0), 'tag') and \

                self.ui.tableWidgetAttr.item(row, 0).data(Qt.UserRole).IsProp == 2: return

                dialog = SymbolAttrCodeTableDialog(self, str(self.ui.tableWidgetAttr.item(row, 0).data(Qt.UserRole).UID),

                                                   tableDatas=self.ui.tableWidgetAttr.item(row, 7).data(Qt.UserRole))

                    self.ui.tableWidgetAttr.item(row, 7).setData(Qt.UserRole, code_data)

                dialog = SymbolAttrTargetDialog(self, symbolType, self.ui.tableWidgetAttr.item(row, 6).data(Qt.UserRole))

                    self.ui.tableWidgetAttr.item(row, 6).setData(Qt.UserRole, target)

        """load data from database"""

        app_doc_data = AppDocData.instance()

        self.currentTypeId = app_doc_data.getSymbolTypeId(symbolType)

        attrs = app_doc_data.getSymbolAttribute(symbolType)

            item.setData(Qt.UserRole, attr)

            #item.tag = attr

            item.setData(Qt.UserRole, attr.Target)

            #item.tag = attr.Target

            item.setData(Qt.UserRole, attr.Codes.values)

            #item.tag = attr.Codes.values

    def save_data(self):

        try:

            app_doc_data = AppDocData.instance()

            attrs = []

            table = self.ui.tableWidgetAttr

            for index in range(table.rowCount()):

                attr = []

                attr.append(table.item(index, 0).text() if table.item(index, 0) is not None else '')

                attr.append(table.item(index, 1).text() if table.item(index, 1) is not None else '')

                attr.append(table.item(index, 2).text() if table.item(index, 2) is not None else '')

                attr_data_type = table.cellWidget(index, 3).currentText() if table.cellWidget(index, 3) else \

                    table.item(index, 3).text()

                attr.append(attr_data_type)

                attr_at = table.item(index, 4).text() if table.item(index, 4) is not None else ''

                if attr_data_type in ['Text Item', 'Symbol Item'] and not attr_at:

                    QMessageBox.information(self, 'Information', f"'Attr At' must be set for {attr_data_type}")

                    return False

                attr.append(attr_at)  # Attribute At

                attr.append(table.item(index, 5).text() if table.item(index, 5) is not None else '')  # Expression

                attr.append(table.item(index, 6).data(Qt.UserRole) if table.item(index, 6).data(Qt.UserRole) is not None

                            else 'ALL')  # Target

                attr.append(index)

                attr.append(table.item(index, 0).data(Qt.UserRole).IsProp) if table.item(index, 0).data(Qt.UserRole) else \

                    attr.append(0)

                attr.append(table.item(index, 7).data(Qt.UserRole))   # code table

                attrs.append(attr)

            app_doc_data.saveSymbolAttributes(self.currentTypeId, attrs, self._symbolType)

            return True

        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 False

        item.setData(Qt.UserRole, 'ALL')

        item.setData(Qt.UserRole, [])

        item.setData(Qt.UserRole, attr)

        #item.tag = attr

        if row != -1 and not (hasattr(self.ui.tableWidgetAttr.item(row, 0), 'tag') and

                              self.ui.tableWidgetAttr.item(row, 0).data(Qt.UserRole).IsProp == 2):

            if not self.save_data():