HYTOS

# coding: utf-8

""" This is line no tracer module """

import sys

import math

import shapely

from AppDocData import AppDocData, MessageType

from EngineeringLineItem import QEngineeringLineItem

from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

from QEngineeringFlowArrowItem import QEngineeringFlowArrowItem

from SymbolSvgItem import SymbolSvgItem

from EngineeringTextItem import QEngineeringTextItem

from EngineeringUnknownItem import QEngineeringUnknownItem

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

except ImportError:

    try:

        from PyQt4.QtCore import *

        from PyQt4.QtGui import *

    except ImportError:

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

class LineNoTracer:

    '''

        @history    2018.04.26 Jeongwoo Variable name changed (texts → lineNos)

    '''

    def __init__(self, symbols, lines, lineNos, specBreak, lineIndicator, vendor):

        try:

            self._symbols = symbols

            self._lines = lines

            self._lineNos = lineNos

            self._spec_breaks = specBreak

            self._lineIndicator = lineIndicator

            """

            for spec in self._specBreak:

                for attr in spec.attrs:

                    if type(attr) is tuple and attr[1] != '':

                        self._specBreakUID.append(attr[1])

            """

        except Exception as ex:

            from App import App 

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

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

    '''

        @brief  find primary lines connected to given line no

        @author humkyung

    '''

    def find_primary_lines(self, lineno):

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringRunItem import QEngineeringRunItem

        connected_items = []

        _from = lineno.prop('From')

        _to = lineno.prop('To')

        if _from and _to and lineno.empty():

            connected_items = self.find_connected_objects(_from, to=_to)

            if _from in connected_items and _to in connected_items:

                start = connected_items.index(_from)

                end = connected_items.index(_to)

                if start < end:

                    connected_items = connected_items[start:end+1]

                else:

                    connected_items = connected_items[end:start+1]

                    connected_items.reverse()

        elif (not _from or not _to) and (1 == len(lineno.conns)):

            connected_items = self.find_connected_objects(lineno.conns[0])

        if connected_items:

            for item in connected_items: 

                item.owner = lineno # set item's owner

            line_run = QEngineeringRunItem()

            line_run.items = connected_items

            line_run.arrange_flow_direction()

            line_run.owner = lineno

            lineno.runs.append(line_run)

            lineno.set_property('From', connected_items[0])

            lineno.set_property('To', connected_items[-1])

        if _to is not None and (not connected_items or connected_items[-1] is not _to):

            _to.owner = None

        return connected_items

    '''

        @brief  find secondary lines

        @author humkyung

    '''

    def find_secondary_lines(self, lines):

        from EngineeringAbstractItem import QEngineeringAbstractItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringRunItem import QEngineeringRunItem

        try:

            foundCount = 1

            while foundCount:

                foundCount = 0

                notMatches = []

                for line in lines:

                    if line.owner is not None: continue

                    line_matches = [x for x in self._lines if x.owner and line.is_connected(x, QEngineeringAbstractItem.CONNECTED_AT_BODY)]

                    symbol_matches = [x for x in self._symbols if x.owner and line.is_connected(x)]

                    if line_matches or symbol_matches:

                        foundCount += 1

                        connected_items = self.find_connected_objects(line)

                        owner = line_matches[0].owner if line_matches else symbol_matches[0].owner

                        for item in connected_items:

                            item.owner = owner # set item's owner

                        line_run = QEngineeringRunItem()

                        line_run.items = connected_items

                        line_run.arrange_flow_direction()

                        if line_run.items is not None and len(line_run.items) > 0:

                            line_run.owner = owner

                            owner.runs.append(line_run)

                    else:

                        notMatches.append(line)

                lines = notMatches

        except Exception as ex:

            from App import App 

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

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

    '''

        @brief      trace line no

        @author     humkyung

        @date       2018.04.16

        @history    2018.04.26 Jeongwoo docDatalineNos = self.lineNos, Not For loop

                    humkyung 2018.05.08 add flow arrow

                    Jeongwoo 2018.05.14 Add [runs] on Primary/Secondary Line - Need to modify Secondary Line

                    Jeongwoo 2018.05.15 Make Comments [lineno.conns[0].owner = lineno]

                    Jeongwoo 2018.05.17 Modify find secondary lines with 'while'

                                        Modify find secondary lines with 'while' used sublist for unconnected line

                    humkyung 2018.05.18 set start line's owner before tracing

    '''

    def execute(self, displayMessage, updateProgress, toler=50):

        from EngineeringLineItem import QEngineeringLineItem

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringRunItem import QEngineeringRunItem

        from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem

        try:

            docData = AppDocData.instance()

            configs = docData.getConfigs('Line No', 'Delimiter')

            if 1 == len(configs):

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

                for lineno in self._lineNos:

                    _from = lineno.prop('From')

                    _to = lineno.prop('To')

                    if _from and _to and (type(_from) is QEngineeringLineItem or issubclass(type(_from), SymbolSvgItem)) and (type(_to) is QEngineeringLineItem or issubclass(type(_to), SymbolSvgItem)) :

                        _from.owner = lineno

                        _to.owner = lineno

                        continue

                    else:

                        lineno.set_property('From', None)

                        lineno.set_property('To', None)

                    lineno.conns.clear()

                    minDist = None

                    startLine = None

                    for line in self._lines:

                        dist = line.distanceTo((lineno.center().x(), lineno.center().y()))

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

                            minDist = dist

                            startLine = line

                    if (startLine is not None) and (minDist < toler):

                        lineno.conns.append(startLine)

                        startLine.owner = lineno

                """

                ## lineIndicator

                extendPixel = 30

                for lineIndicator in self._lineIndicator:

                    maxOverLap = 0

                    matchLineNo = None

                    liInRect = [round(lineIndicator.boundingRect().x()), round(lineIndicator.boundingRect().y()), round(lineIndicator.boundingRect().x() + lineIndicator.boundingRect().width()), round(lineIndicator.boundingRect().y() + lineIndicator.boundingRect().height())]

                    for remainLineNo in remainLineNos:

                        xOverlap = False

                        yOverlap = False

                        extendDx = remainLineNo.size[0] if lineIndicator.isVH == 'V' else remainLineNo.size[1]

                        reNoRect = [round(remainLineNo.loc[0] - extendDx), round(remainLineNo.loc[1] - extendDx), round(remainLineNo.loc[0] + remainLineNo.size[0] + extendDx), round(remainLineNo.loc[1] + remainLineNo.size[1] + extendDx)]

                        w, h = 0, 0                        

                        for x1 in range(reNoRect[0], reNoRect[2] + 1):

                            for x2 in range(liInRect[0], liInRect[2] + 1):

                                if x1 - x2 is 0:

                                    xOverlap = True

                                    w += 1

                        if not xOverlap:

                            continue

                        for y1 in range(reNoRect[1], reNoRect[3] + 1):

                            for y2 in range(liInRect[1], liInRect[3] + 1):

                                if y1 - y2 is 0:

                                    yOverlap = True

                                    h += 1

                        if not xOverlap or not yOverlap:

                            continue

                        overLapRate = (w / lineIndicator.boundingRect().width() * 100) if lineIndicator.boundingRect().width() > lineIndicator.boundingRect().height() else (h / lineIndicator.boundingRect().height() * 100)

                        #print(overLapRate)

                        if maxOverLap < overLapRate:

                            maxOverLap = overLapRate

                            matchLineNo = remainLineNo

                            #lineIndicator.setBrush(QBrush(QColor(255, 0, 0, 127)))

                    if matchLineNo is not None:

                        #print(matchLineNo.text() + ' indicator : ' + str(lineIndicator.boundingRect().x()) + ', ' + str(lineIndicator.boundingRect().y()))

                        matchLine = None

                        x1, y1, x2, y2 = int(lineIndicator.boundingRect().x() + lineIndicator.otherLine[0]), int(lineIndicator.boundingRect().y() + lineIndicator.otherLine[1]), int(lineIndicator.boundingRect().x() + lineIndicator.otherLine[2]), int(lineIndicator.boundingRect().y() + lineIndicator.otherLine[3])

                        #print([type(x1), type(y1), type(x2), type(y2)])

                        startXorY = (min(liInRect[0], liInRect[2]) - extendPixel) if lineIndicator.isVH == 'V' else (min(liInRect[1], liInRect[3]) - extendPixel)

                        endXorY = (max(liInRect[0], liInRect[2]) + extendPixel) if lineIndicator.isVH == 'V' else (max(liInRect[1], liInRect[3]) + extendPixel)

                        fXorY = []

                        for dXOrdY in range(startXorY, endXorY + 1): # if horizontal -> Y, if vertical -> X

                            if lineIndicator.isVH == 'V':

                                fXorY.append(round(((y2-y1)/(x2-x1))*dXOrdY + y1 - ((y2-y1)/(x2-x1))*x1)) # f(x)

                            else:

                                fXorY.append(round(((x2-x1)/(y2-y1))*dXOrdY + x1 - ((x2-x1)/(y2-y1))*y1)) # f(y)

                        #print(self._lines)

                        for line in self._lines:

                            axis1Overlap = False

                            axis2Overlap = False

                            lX1, lY1, lX2, lY2 = int(line.startPoint()[0]), int(line.startPoint()[1]), int(line.endPoint()[0]), int(line.endPoint()[1])

                            #print([lX1, lY1, lX2, lY2])

                            if lineIndicator.isVH == 'V':

                                range11 = range(startXorY, endXorY + 1)

                                range12 = range(min(lX1, lX2), max(lX1, lX2)+ 1)

                                range21 = fXorY

                                range22 = range(min(lY1, lY2), max(lY1, lY2) + 1)

                            else:

                                range11 = range(startXorY, endXorY + 1)

                                range12 = range(min(lY1, lY2), max(lY1, lY2) + 1)

                                range21 = fXorY

                                range22 = range(min(lX1, lX2), max(lX1, lX2) + 1)

                            #print(fXorY)

                            #print(type(fXorY[0]))

                            #print([range11[0],range11[-1], range12[0],range12[-1], range21[0],range21[-1], range22[0],range22[-1]])

                            for axis11 in range11:

                                for axis12 in range12:

                                    if axis11 - axis12 is 0:

                                        axis1Overlap = True

                                        break

                                if axis1Overlap: break

                            if not axis1Overlap:

                                continue

                            for axis21 in range21:

                                for axis22 in range22:

                                    if axis21 - axis22 is 0:

                                        axis2Overlap = True

                                        break

                                if axis2Overlap: break

                            if axis1Overlap and axis2Overlap:

                                matchLine = line

                                break

                        if matchLine is not None:

                            matchLineNo.conns.append(matchLine)

                            lineIndicator.lineIndicator = 'Match'

                            lineIndicator.setBrush(QBrush(QColor(0, 0, 255, 127)))

                            #print('connected ' + matchLineNo.text() + ' and ' + matchLine.uid)                     

                ## up to here

                """

                maxValue = len(self._lineNos) + 1   ## line no's count + secondary line

                # find primary lines

                # sort line no with from,to value

                self._lineNos.sort(key=lambda line_no:(1 if line_no.prop('From') else 0)+(1 if line_no.prop('To') else 0),reverse=True)

                for lineno in self._lineNos:

                    if displayMessage: displayMessage.emit('{} {}'.format(lineno.text(), 'Topology Construction'))

                    self.find_primary_lines(lineno)

                    if updateProgress: updateProgress.emit(maxValue)

                # find secondary lines

                lines = self._lines

                self.find_secondary_lines(lines)

                if updateProgress: updateProgress.emit(maxValue)

            ### make trim lines

            """

            updateProgress.emit(-1) # reset progressbar

            displayMessage.emit('Unknown line Topology Construction')

            orphanLines = [line for line in self._lines if line.owner is None] 

            if orphanLines:

                maxValue = len(orphanLines)

                orphanLines = sorted(orphanLines, key=lambda param:param.length(), reverse=True)

                while len(orphanLines) > 0:

                    trimLineNo = QEngineeringTrimLineNoTextItem()

                    trimLineNo.conns.append(orphanLines[0])

                    orphanLines[0].owner = trimLineNo

                    orphanLines[0].linkedItem = trimLineNo

                    connectedItems = self.findPrimaryLines(trimLineNo)

                    for item in connectedItems:

                        if item in orphanLines:

                            orphanLines.remove(item)

                            updateProgress.emit(maxValue)

                    self.findSecondaryLines(orphanLines)

                    for item in orphanLines[:]:

                        if item.owner is not None:

                            orphanLines.remove(item)

                            updateProgress.emit(maxValue)

                    docData.tracerLineNos.append(trimLineNo)

            """

            if updateProgress: updateProgress.emit(maxValue)

        except Exception as ex:

            from App import App 

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

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

    '''

        @brief      find objects connected to given line while loop

        @author     humkyung

        @date       2018.04.16

        @history    humkyung 2018.05.08 find symbol or line connected to given object

                    humkyung 2018.05.10 set found object's owner

                    humkyung 2018.05.17 try to connect both symbol and line

                    humkyung 2018.06.22 order connected objects

    '''

    def find_connected_objects(self, start, to=None):

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringEquipmentItem import QEngineeringEquipmentItem

        from SymbolSvgItem import SymbolSvgItem

        visited = [start]

        try:

            pool = []

            pool.append((0, start))

            while len(pool) > 0:

                sign, obj = pool.pop()

                """ check obj is upstream or downstream of spec break """

                matches = [spec_break for spec_break in self._spec_breaks if spec_break.is_connected(obj)]

                if matches or issubclass(type(obj), QEngineeringEquipmentItem): continue

                """ end loop if obj is to """

                if to is not None and str(obj.uid) == str(to.uid): break

                if type(obj) is QEngineeringLineItem:

                    symbolMatches = [x for x in self._symbols if (x.owner is None or x.owner == start.owner) and (x not in visited) and obj.is_connected(x)]

                    lineMatches = [x for x in self._lines if (x.owner is None or x.owner == start.owner) and (x is not obj) and (x not in visited) and obj.is_connected(x)]

                elif issubclass(type(obj), SymbolSvgItem):

                    lineMatches = [x for x in self._lines if (x.owner is None or x.owner == start.owner) and (x not in visited) and obj.is_connected(x)]

                    if len(lineMatches) > 1: # choose one if connected lines are more than 2

                        matches = [x for x in [visited[0], visited[-1]] if obj.is_connected(x)]

                        if matches:

                            next_connected = [x for x in lineMatches if obj.next_connected(x, matches[0])]

                            if next_connected: lineMatches = next_connected

                    symbolMatches = [x for x in self._symbols if (x.owner is None or x.owner == start.owner) and (x is not obj) and (x not in visited) and obj.is_connected(x, None)]

                    #print(symbolMatches)

                # order connected objects

                matches = []

                matches.extend(symbolMatches)

                matches.extend(lineMatches)

                if sign == 0 and len(matches) > 1:

                    mid = int(len(matches)*0.5)

                    lhs = matches[0:mid]

                    rhs = matches[mid:]

                elif sign == -1:

                    lhs = matches

                    rhs = []

                else:

                    lhs = []

                    rhs = matches

                for match in lhs:

                    pool.append((-1, match))

                    visited.insert(0, match)

                for match in rhs:

                    pool.append((1, match))

                    visited.append(match)

                # up to here

        except Exception as ex:

            from App import App 

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

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

        return visited

'''

    @brief      connect attributes

    @author     humkyung

    @date       2018.06.17

    @history    humkyung 2018.06.21 paste connect attributes codes from recognizeLine function

                kyouho  2018.09.14  clear Item's owner 

'''

def connectAttrImpl(worker, update_line_type):

    import os

    from App import App

    from LineNoTracer import LineNoTracer

    from AppDocData import AppDocData

    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

    try:

        symbols = []

        lines = []

        lineNos = []

        specBreak = []

        lineIndicator = []

        vendor_packages = [item for item in worker.graphicsView.scene.items() if type(item) is QEngineeringVendorItem]

        end_breaks = [item for item in worker.graphicsView.scene.items() if type(item) is QEngineeringEndBreakItem]

        for end_break in end_breaks:

            worker.graphicsView.scene.removeItem(end_break)

        configs = AppDocData.instance().getConfigs('Supplied by Tag Rule', 'by Vendor')

        vendorTag = configs[0].value if configs else 'By Vendor'

        for item in worker.graphicsView.scene.items():

            if type(item) is QEngineeringSpecBreakItem:

                specBreak.append(item)

            elif issubclass(type(item), SymbolSvgItem) and not type(item) is QEngineeringUnknownItem:

                matches = [vendor_package for vendor_package in vendor_packages if vendor_package.includes(item)]

                if matches:

                    item.set_property('Supplied By', vendorTag)

                else:

                    item.set_property('Supplied By', '')

                symbols.append(item)

            elif type(item) is QEngineeringLineNoTextItem:

                lineNos.append(item)

            elif type(item) is QEngineeringLineItem:

                #matches = [vendor_package for vendor_package in vendor_packages if vendor_package.includes(item)]

                #if not matches: lines.append(item)

                lines.append(item)

            elif type(item) is QEngineeringUnknownItem and item.lineIndicator != 'False':

                lineIndicator.append(item)

        # trace line no

        tracer = LineNoTracer(symbols, lines, lineNos, specBreak, lineIndicator, vendor_packages)

        tracer.execute(worker.displayMessage, worker.updateProgress)

        # up to here

        # connect attribute

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

        for symbol in symbols:

            try:

                symbol.connectAttribute(texts)

            except Exception as ex:

                from App import App 

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

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

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

        labels = [symbol for symbol in symbols if type(symbol) is QEngineeringInstrumentItem and not symbol.is_connected]

        valves = [symbol for symbol in symbols if type(symbol) is not QEngineeringInstrumentItem and type(symbol) is not QEngineeringReducerItem and type(symbol) is not QEngineeringEquipmentItem \

            and type(symbol) is not QEngineeringOPCItem and type(symbol) is not QEngineeringSpecBreakItem]

        for valve in valves:

            valve.connectAttribute(labels, clear=False)

        """ update line type """

        if update_line_type == True:

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

            #for line in lines: line.lineType = 'Primary'

            for line in lines: line.update_line_type()

        """make end break"""

        docdata = AppDocData.instance()

        end_break_names = docdata.getSymbolListByType('type', 'End Break')

        if len(end_break_names) is not 0:

            svgFileName = end_break_names[0].sName

            symbol = AppDocData.instance().getSymbolByQuery('name', svgFileName)

            svgFilePath = os.path.join(AppDocData.instance().getCurrentProject().getSvgFilePath(), symbol.getType(), svgFileName+'.svg')

            end_breaks = []

            lineNo_froms = []

            lineNo_tos = []

            for lineNo in lineNos:

                lineNo_froms.append(lineNo.prop('From')) if lineNo.prop('From') is not None else None

                lineNo_tos.append(lineNo.prop('To')) if lineNo.prop('To') is not None else None

                #end_breaks.extend(lineNo.end_break())

            for line_end in lineNo_froms + lineNo_tos:

                #print(type(line_end))

                for connector in line_end.connectors:

                    if connector.connectedItem is not None and connector.connectedItem.owner is not line_end.owner:

                        end_break = SymbolSvgItem.createItem(symbol.getType(), svgFilePath)

                        pt = [connector.center()[0] - float(symbol.getOriginalPoint().split(',')[0]), connector.center()[1] - float(symbol.getOriginalPoint().split(',')[1])]

                        origin = [0,0]

                        if 2 == len(symbol.getOriginalPoint().split(',')):

                            tokens = symbol.getOriginalPoint().split(',')

                            origin = [pt[0] + float(tokens[0]), pt[1] + float(tokens[1])]

                        end_break.buildItem(svgFileName, symbol.getType(), 5.7, pt, [end_break.boundingRect().width(), end_break.boundingRect().height()], origin, [], symbol.getBaseSymbol(), symbol.getAdditionalSymbol(), symbol.getHasInstrumentLabel())

                        end_break.set_property('Connected Item', connector.connectedItem)

                        end_break.setToolTip('owner : ' + str(line_end))

                        end_break.area = 'Drawing'

                        end_break.owner = line_end

                        end_breaks.append(end_break)

            '''

            for lineNo_from in lineNo_froms + lineNo_tos:

                for connector in lineNo_from.connectors:

                    for lineNo_to in lineNo_tos + lineNo_froms:

                        if lineNo_from is lineNo_to or lineNo_from.owner is lineNo_to.owner : continue

                        if connector.connectedItem is lineNo_to:

                            end_break = SymbolSvgItem.createItem(symbol.getType(), svgFilePath)

                            pt = [connector.center()[0] - float(symbol.getOriginalPoint().split(',')[0]), connector.center()[1] - float(symbol.getOriginalPoint().split(',')[1])]

                            origin = [0,0]

                            if 2 == len(symbol.getOriginalPoint().split(',')):

                                tokens = symbol.getOriginalPoint().split(',')

                                origin = [pt[0] + float(tokens[0]), pt[1] + float(tokens[1])]

                            end_break.buildItem(svgFileName, symbol.getType(), 5.7, pt, [end_break.boundingRect().width(), end_break.boundingRect().height()], origin, [], symbol.getBaseSymbol(), symbol.getAdditionalSymbol(), symbol.getHasInstrumentLabel())

                            end_break.set_property('Connected Item', lineNo_to)

                            end_break.setToolTip('owner : ' + str(lineNo_from))

                            end_break.area = 'Drawing'

                            end_break.owner = lineNo_from

                            end_breaks.append(end_break)

            '''

            if end_breaks:

            # check dulplication

                dupl = set()

                for i in range(len(end_breaks)):

                    for j in range(len(end_breaks)):

                        if i == j: continue

                        else:

                            setI = set([end_breaks[i].owner, end_breaks[i].prop('Connected Item')])

                            setJ = set([end_breaks[j].owner, end_breaks[j].prop('Connected Item')])

                            if not (setI - setJ):

                                index = [i, j]

                                index.sort()

                                index = tuple(index)

                                dupl.add(index)

                #print(dupl)

                dupl = list(set([indexSet[1] for indexSet in list(dupl)]))

                dupl.sort(reverse=True)

                #print(dupl)

                for index in dupl:

                    end_breaks.pop(index)

                for end_break in end_breaks:

                    end_break.transfer.onRemoved.connect(App.mainWnd().itemRemoved)

                    end_break.addSvgItemToScene(worker.graphicsView.scene)

    except Exception as ex:

        from App import App 

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

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

    finally:

        worker.finished.emit()