HYTOS

    from App import App

    import uuid

    from LineNoTracer import LineNoTracer

    from AppDocData import AppDocData

    from EngineeringAbstractItem import QEngineeringAbstractItem

    from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

    from EngineeringInstrumentItem import QEngineeringInstrumentItem

    from EngineeringReducerItem import QEngineeringReducerItem

    from EngineeringEquipmentItem import QEngineeringEquipmentItem

    from QEngineeringOPCItem import QEngineeringOPCItem

    from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

    from EngineeringVendorItem import QEngineeringVendorItem

    from EngineeringEndBreakItem import QEngineeringEndBreakItem

    from EngineeringFlowMarkItem import QEngineeringFlowMarkItem

    from EngineeringReservedWordTextItem import QEngineeringReservedWordTextItem

    from QEngineeringSizeTextItem import QEngineeringSizeTextItem

    from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

    from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem

    from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

    from EngineeringErrorItem import QEngineeringErrorItem

    from EngineeringTextItem import QEngineeringTextItem

    from SpecialItemTypesDialog import SpecialItemTracer

    try:

        docdata = AppDocData.instance()

        worker.display_message.emit('Initializing...')

        ALL_ITEM = [item for item in worker.scene.items() if issubclass(type(item), QEngineeringAbstractItem)]

        for item in ALL_ITEM:

            item.setVisible(False)

        QApplication.processEvents()

        symbols = []

        lines = [item for item in worker.scene.items() if type(item) is QEngineeringLineItem]

        lineNos = []

        equip_packages = []

        end_breaks = []

        for error_item in [item for item in worker.scene.items() if type(item) is QEngineeringErrorItem]:

            error_item.transfer.onRemoved.emit(error_item)

        for end_break in [item for item in worker.scene.items() if type(item) is QEngineeringEndBreakItem]:

            if not end_break.prop('Freeze'):

                end_break.transfer.onRemoved.emit(end_break)

            else:

                end_breaks.append(end_break)

        QApplication.processEvents()

        for item in worker.scene.items():

            if issubclass(type(item), SymbolSvgItem) and not (type(item) is QEngineeringErrorItem) and not (

                    type(item) is QEngineeringUnknownItem) and item.type != 'Notes' and not (

                    type(item) is QEngineeringEndBreakItem):

                symbols.append(item)

            elif type(item) is QEngineeringLineNoTextItem:

                lineNos.append(item)

            elif issubclass(type(item), QEngineeringTextItem):

                item.owner = None

        QApplication.processEvents()

        # trace connected items

        docdata._connected_items_lists.clear()

        connected_items_lists = docdata._connected_items_lists

        items = symbols + lines

        while items:

            connected_items_list = [items[0]]

            connected_items_count = 0

            while True:

                if connected_items_count == len(connected_items_list):

                    break

                else:

                    connected_items_count = len(connected_items_list)

                for item in items:

                    if item in connected_items_list:

                        continue

                    else:

                        matches = [conn for conn in item.connectors if conn.connectedItem and conn.connectedItem in connected_items_list]

                        if matches:

                            connected_items_list.append(item)

                            break

            for item in connected_items_list:

                items.remove(item)

            connected_items_lists.append(connected_items_list)

        # up to here

        # connect attribute

        worker.display_message.emit('Connecting Attribute...')

        QApplication.processEvents()

        texts = [item for item in worker.scene.items() if issubclass(type(item), QEngineeringTextItem)]

        for symbol in symbols:

            try:

                symbol.connectAttribute(texts)

            except Exception as ex:

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

                                                               sys.exc_info()[-1].tb_lineno)

                worker.display_message.emit(message)

        """ try to connect label to valve """

        labels = [symbol for symbol in symbols if symbol.iType == 19]  # Labels - Symbol => Instrument

        valves = [symbol for symbol in symbols if

                  symbol.iType == 34 or symbol.iType == 17 or symbol.iType == 22]  # Specialty Components, In-Line, Relief Devices

        for label in labels:

            label.connectAttribute(valves, clear=False)

        # for slope, etc.., symbol to line

        labels = [symbol for symbol in symbols if symbol.iType == 30]  # Labels - Line => Piping

        for label in labels:

            label.connectAttribute(lines, clear=False)

        QApplication.processEvents()

        for symbol in symbols:

            for assoc in symbol.associations():

                if assoc.owner is None:

                    assoc.owner = symbol

        """ try to find text item's owner """

        texts = [item for item in worker.scene.items() if type(item) is QEngineeringReservedWordTextItem]

        for text in texts:

            text.findOwner(lines)

        QApplication.processEvents()

        # restore and save manual edited attr's text item

        texts = [item for item in worker.scene.items() if issubclass(type(item), QEngineeringTextItem)]

        targetText = []

        for text in texts:

            found = False

            for symbol in symbols + lines:

                for attr in list(symbol.attrs.keys()):

                    # skip freezed attr or already consumed by symbol

                    if attr.AssocItem == text:

                        text.owner = symbol

                        found = True

                        break

                    # restore missing attr

                    elif type(attr.AssocItem) is str or type(attr.AssocItem) is uuid.UUID:

                        if str(attr.AssocItem) == str(text.uid):

                            symbol.add_assoc_item(text)

                            attr.AssocItem = text

                            text.owner = symbol

                            found = True

                        break

                if found: break

            if not found and (

                    type(text) is QEngineeringSizeTextItem or type(text) is QEngineeringValveOperCodeTextItem or \

                    type(text) is QEngineeringTagNoTextItem or type(text) is QEngineeringTextItem):

                targetText.append(text)

        worker.need_update_texts = []

        targetText = sorted(targetText, key=lambda param: len(param.text()), reverse=True)

        for symbol in symbols + equip_packages:

            symbol._skip = False

        for text in targetText:

            ret = text.findOwner(symbols) if type(text) is not QEngineeringTagNoTextItem else text.findOwner(

                symbols + equip_packages)

            if ret:

                worker.need_update_texts.append([text, ret])

        QApplication.processEvents()

        worker.updateProgress.emit(tracer.maxValue)

        ALL_ITEM = [item for item in worker.scene.items() if issubclass(type(item), QEngineeringAbstractItem)]

        for item in ALL_ITEM:

            item.setVisible(True)

    except Exception as ex:

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

                                                       sys.exc_info()[-1].tb_lineno)

        worker.display_message.emit(message)

    except:

        (type1, value, traceback) = sys.exc_info()

        sys.excepthook(type1, value, traceback)