HYTOS

    app = App(sys.argv)

    """ log for unhandled exception """

        dlg = Ui_Dialog()

        selectedProject = dlg.showDialog()

        if selectedProject is not None:

            AppDocData.instance().setCurrentProject(selectedProject)

            app._mainWnd = MainWindow.instance()

            app._mainWnd.show()

            sys.exit(app.exec_())

        from xml.etree import ElementTree

        from xml.dom import minidom

    def export_as_svg(self, file_path):

        """export to svg file"""

        from xml.etree.ElementTree import Element, tostring, SubElement, dump, ElementTree, parse

        if not file_path:

            options = QFileDialog.Options()

            svg.attrib['version'] = "1.2"

            svg.attrib['baseProfile'] = "tiny"

            for item in self._scene.items():

                    if node:

            with open(save_file_path, 'w', encoding='utf-8') as output_file:

                output_file.write(self.prettify(svg))

'''

    """ This is Worker class """

    from PyQt5.QtWidgets import QApplication, QLabel, QWidget, QGridLayout, QListWidget

    from QtImageViewer import QtImageViewer

    import sys

        super(Worker, self).__init__()

        self.need_update_texts = []

    '''

        @brief  execute connecting attributes

        @date   2018.06.17

    '''

    def run(self):  # A slot takes no params

        try:

        except Exception as ex:

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

class QConnectAttrDialog(QDialog):

        self.ui.listWidget.model().rowsInserted.connect(self.rowInserted)  # connect to func rowInserted(self, item)

        self.isRunned = False

    @property

    def validation_checked(self):

        """return if validation is checked"""

        return self.ui.checkBoxValidation.isChecked()

        """start to connect attributes"""

        self.ui.buttonBox.setEnabled(False)

        self.ui.pushButtonStart.setEnabled(False)

        self.ui.progressBar.setValue(0)

        self.isRunned = True

    '''

        @date   2018.06.17

    '''

        import timeit

        try:

            self.ui.buttonBox.setDisabled(True)

            # 1 - create Worker and Thread inside the Form

                              self.ui.checkBoxUpdateFlowMark.isChecked(), self.ui.checkBoxUpdateSpec.isChecked())

        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)

        finally:

            self.ui.listWidget.addItem("\nRunning Time : {} min".format(str(round(seconds / 60, 1))) + "\n")

import logging

from datetime import datetime

class QExceptionHandler(QObject):

    """ This is exception handler class """

        self.log_path = os.path.join(os.getenv('ALLUSERSPROFILE'), 'Digital PID', 'id2.log')

        self.logger = logging.getLogger(__name__)

    def handler(self, exctype, value, traceback):

        """ log exception, file name and line number """

        from App import App

        from AppDocData import MessageType

        message = 'Unhandled exception: {}'.format(message)

        self.errorSignal.emit()

        self.logger.critical(message)

        message = 'CRITICAL : Unhandled exception: {}'.format(message)

        try:

        except Exception as ex:

                if foundItems is not None:

                    for item in foundItems:

                        data = item.data(0, self.TREE_DATA_ROLE)

                            parentData = parent.data(0, self.TREE_DATA_ROLE)

                            if parentData is not None and issubclass(type(parentData), QEngineeringLineNoTextItem):

                                for index in range(len(parentData.runs)):

        from EngineeringEquipmentItem import QEngineeringEquipmentItem

        try:

            if 1 == len(configs):

                    minDist = None

                    startLine = None

                    for line in [line for line in self._lines if line.owner is None and line.is_piping(strong=True)]:

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

                            minDist = dist

                            startLine = line

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

                        if not _from or not _to:

                    else:

                # find primary lines

                # sort line no with from,to value

                            orphans.remove(item)

                            updateProgress.emit(self.maxValue)

            if updateProgress: updateProgress.emit(self.maxValue)

        except Exception as ex:

            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)

    '''

    from EngineeringLineTracerRunItem import QEngineeringLineTracerRunItem

    try:

        docdata = AppDocData.instance()

        symbols = []

        lines = docdata.lines

        lineNos = []

            else:

                end_breaks.append(end_break)

        '''

        for flow_mark in [item for item in worker.scene.items() if type(item) is QEngineeringFlowMarkItem]:

            if not flow_mark.prop('Freeze'):

            elif item.type == 'Notes':

                notes.append(item)

        # remove unknown line's

        pastTrim = docdata.tracerLineNos

        treeWidget = App.mainWnd().itemTreeWidget

        # trace line no

        tracer = LineNoTracer(symbols, lines, lineNos, spec_breaks, lineIndicator, vendor_packages, end_breaks)

        # up to here

        # connect attribute

        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:

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

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

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

        for label in labels:

            label.connectAttribute(valves, clear=False)

        for symbol in symbols:

            for assoc in symbol.associations():

                if assoc.owner is None:

        for text in texts:

            text.findOwner(lines)

        # restore and save manual edited attr's text item

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

        targetText = []

        """ update line type """

        if update_line_type:

            for line in lines:

                line.update_line_type()

        """make end break"""

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

        if len(end_break_names) is not 0:

                            'Connected Item').lineType == 'Primary'))):

                            end_break.addSvgItemToScene(worker.scene)

        """ update spec break """

        if update_spec:

            freezed_spec_breaks = []

        worker.updateProgress.emit(tracer.maxValue)

        # trace special item

        # up to here

        # sort run flow order

        fixed_run_infos = []  # QEngineeringLineTracerRunItem s

        waiting_run_infos = []  # QEngineeringLineTracerRunItem s

                run_index += 1

        # second step : determine waiting run flow, connected by point

        remain_count_past = len(waiting_run_infos)

        while True:

            else:

                remain_count_past = remain_count

        # third step : body connected run sort, not split

        remain_count_past = len(waiting_run_infos)

        while True:

        fixed_merged_run_infos = []  # [[run_info1, run_info2, ... in order], [merged run with items]]

        waiting_merged_run_infos = []  # [[run_info1, run_info2, ... in order], [merged run with items]]

        # waiting run merge and sort

        consumed_count_past = 0

        for index1 in range(len(waiting_run_infos)):

                            [[waiting_run_infos[index1], waiting_run_infos[index2]], merged_run_info])

                    break

        while True:

            consumed_count = 0

            for index in range(len(waiting_run_infos)):

            else:

                consumed_count_past = consumed_count

        while True:

            merged = False

            for index1 in range(len(waiting_merged_run_infos)):

            if not merged:

                break

        # fixed run merge

        consumed_count_past = 0

        for index1 in range(len(fixed_run_infos)):

                            [[fixed_run_infos[index1], fixed_run_infos[index2]], merged_run_info])

                    break

        while True:

            consumed_count = 0

            for index in range(len(fixed_run_infos)):

            else:

                consumed_count_past = consumed_count

        while True:

            merged = False

            for index1 in range(len(fixed_merged_run_infos)):

            else:

                fixed_merged_run_infos.append([[fixed_run_info], fixed_run_info])

        # sort merged waiting runs by using merged fixed runs

        remain_count_past = len(waiting_merged_run_infos)

        while True:

            else:

                remain_count_past = remain_count

        """ make flow mark """

        if update_flow_mark:

            for line in lines:

            lineNo.EvaluatedEQ()

    except Exception as ex:

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

    except:

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

        sys.excepthook(type1, value, traceback)

    def toXml(self):

        pass

        pass

    '''

        return node

        """convert line item to svg"""

        import uuid

        from xml.etree.ElementTree import Element, SubElement, dump, ElementTree

        try:

            node = Element('g')

            node.attrib['ID'] = str(self.uid)

            node.attrib['stroke'] = self.pen().color().name()

            node.attrib['stroke-width'] = str(self.pen().width())

            node.attrib['transform'] = f"matrix(" \

                                       f")"

            polyline = Element('polyline')

            start_pt = self.startPoint()

            end_pt = self.endPoint()

            polyline.attrib['points'] = f"{start_pt[0]},{start_pt[1]} " \

                                        f"{end_pt[0]},{end_pt[1]}"

            node.append(polyline)

        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)

    def toSql_return_separately(self):

        """ generate sql phrase to save line to database """

import os.path

import sys

import copy

try:

    from PyQt5.QtCore import Qt, QPointF, QRectF, pyqtSignal, QT_VERSION_STR, QRect

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QBrush, QPen, QTransform, QFont

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR, QRect

from EngineeringTextItem import QEngineeringTextItem

from TextInfo import TextInfo

class QEngineeringLineNoTextItem(QEngineeringTextItem):

    '''

        @history    18.05.14    Jeongwoo    Add variable self.runs

                    humkyung 2018.07.09 add stream no

    '''

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

        from SymbolAttr import SymbolProp

        from EngineeringFreezeItem import QEngineeringFreezeItem

        QEngineeringTextItem.__init__(self, uid, parent)

        self._runs = []

        """ create freeze control """

    @property

    def Size(self):

        """ return line no's size """

        attrs = self.getAttributes()

        return matches[0] if matches else None

    def empty(self):

        for run in self.runs:

            run.visible = visible

    '''

        @brief  getter of runs

        @author humkyung

        @date   2018.05.11

    '''

    @property

    def runs(self):

        return self._runs

        @author humkyung

        @date   2018.05.11

    '''

    @runs.setter

    def runs(self, value):

        self._runs = value

    def hoverEnterEvent(self, event):

        """ highlight line no text and run's item """

        self.hover = True

            for item in run.items:

                item.hoverLeaveEvent(event)

        """ reverse line routine when user press 'C' key """

        if event.key() == Qt.Key_C:

            self.reverse()

        QEngineeringTextItem.keyPressEvent(self, event)

    def update_flow_mark(self, position, minLength):

                pre = None

                preRadian = None

                for item in run.items:

                        pre = item

                        start = item.line().p1()

                        end = item.line().p2()

                        radian = math.atan2(_dir[1], _dir[0]) - math.pi / 2

                        preRadian = radian if radian >= 0 else radian + 2 * math.pi

                        preRadian = abs(preRadian - math.pi)

                        start = item.line().p1()

                        end = item.line().p2()

                        radian = math.atan2(_dir[1], _dir[0]) - math.pi / 2

                        currRadian = radian if radian >= 0 else radian + 2 * math.pi

                        currRadian = abs(currRadian - math.pi)

                        if abs(currRadian - preRadian) > allowed_error_radian:

                            # insert flow mark at pre line

                            if pre.length() > minLength:

                                pre.flowMark = position

                                pre.update_arrow()

                            pre = item

                            preRadian = currRadian

                    pre.flowMark = position

                    pre.update_arrow()

        except Exception as ex:

            from AppDocData import MessageType

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

    """

    def reverse(self):

        """ reverse line routine """

        if self.runs:

            self.runs[0].reverse()

            _from = self.prop('From')

        maxDistance = None

        for i in range(len(pts)):

                dx = pts[i][0] - pts[j][0]

                dy = pts[i][1] - pts[j][1]

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

                    maxDistance = dist

                    res[0] = pts[i]

                    res[1] = pts[j]

        return res

    '''

        @brief      set attribute

        @author     humkyung

        @date       2018.07.20

    '''

    def set_attrib(self, attrib, value):

        matches = [attr for attr in self.attrs if attr.UID == attrib.UID]

        if len(matches) == 1:

        @author     kyouho

        @date       2018.09.06

    '''

    def getLineNoAttributes(self, _attrs=None):

        from SymbolAttr import SymbolAttr

        from Configs import LineNoConfig

                        matches = [attr for attr in self.attrs if attr.UID == prop.UID]

                        if len(matches) == 1:

                            _attrs[matches[0]] = self.attrs[matches[0]]

                        #    _attrs[prop] = ''

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

        return _attrs

    @staticmethod

                item.setToolTip('<b>{}</b><br>LINE NO={}'.format(str(item.uid), text))

                """ apply freeze value """

                if connline is not None:

                    item.conns.append(connline)

            from App import App

            from AppDocData import MessageType

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

            return None

            item = TextItemFactory.instance().createTextItem(textInfo)

            if item is not None:

                for prop_node in node.iter('PROPERTY'):

                    if matches:

                        item._properties[matches[0]] = matches[0].parse_value(prop_node.text)

                for attr_node in node.iter('ATTRIBUTE'):

                    attr = SymbolAttr.fromXml(attr_node)

                    item.attrs[attr] = attr_node.text

                item.setToolTip('<b>{}</b><br>LINE NO={}'.format(str(item.uid), text))

                """ apply freeze value """

                if connline is not None:

                    item.conns.append(connline)

            from App import App

            from AppDocData import MessageType

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

            return None

        @history    humkyung 2018.05.02 write symbol's attribute

                    humkyung 2018.05.16 write run information to xml

    '''

    def toXml(self):

        from xml.etree.ElementTree import Element, SubElement, dump, ElementTree

        from EngineeringLineItem import QEngineeringLineItem

            node.append(uidNode)

            textNode = Element('TEXT')

            node.append(textNode)

            locNode = Element('LOCATION')

                node.append(run.toXml())

            properties_node = Element('PROPERTIES')

                prop_node = prop.toXml()

                prop_node.text = str(value) if value else ''

                properties_node.append(prop_node)

                if key.UID is not None:

                    attrNode = key.toXml()

                    attrNode.text = str(_attrs[key])

            if self.conns:

                connNode = Element('CONNLINE')

                connNode.text = str(self.conns[0].uid) if hasattr(self.conns[0], 'uid') else str(self.conns[0])

                node.append(connNode)

            sceneNode = Element('SCENE')

            node.append(sceneNode)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

            return None

    def end_break(self):

        '''

            @brief  end break check

            svgFileName = end_break_names[0].sName

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

            for line_end in [line_from, line_to]:

                for connector in line_end.connectors:

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

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

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

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

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

                        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)

        except Exception as ex:

            from AppDocData import MessageType

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

        return end_breaks

    '''

        @author Jeongwoo

        @date   2018.05.15

    '''

    def getConnectedItems(self):

        visited = []

            from App import App

            from AppDocData import MessageType

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

        return visited

    def explode(self, remainFromTo=False):

        """ explode line no """

        try:

            for index in reversed(range(len(self.runs))):

                self.runs[index].explode()

        @author     humkyung

        @date       2018.08.14

    '''

    def toSql_return_separately(self):

        import uuid

        from EngineeringAbstractItem import QEngineeringAbstractItem

        resLater = []

        app_doc_data = AppDocData.instance()

        if type(self) is QEngineeringLineNoTextItem:

        else:

        sql = 'insert into Components({}) values({})'.format(','.join(cols), ','.join(values))

        res.append((sql, tuple(params)))

        values = ['?', '?', '?', '?']

        params = []

        attrs = self.getAttributes()

                continue

            params.append((str(uuid.uuid4()), str(self.uid), str(key.UID), str(value)))

        sql = 'insert into LineNoAttributes({}) values({})'.format(','.join(cols), ','.join(values))

            _index += 1

        return res, resLater

    '''

        @brief      return Line Data List

        @author     kyouho

        @date       2018.08.14

    '''

    def getLineDataList(self):

        dataList = []

        try:

                if type(key) is not UserInputAttribute:

                    lineProp = docData.getLinePropertiesByUID(key.UID)

                    if lineProp:

                    else:

                    data = attrs[key]

                    if attrName == 'NOMINALDIAMETER':

            from App import App

            from AppDocData import MessageType

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

        if dataList[0] == '':

                if type(items[0]) is QEngineeringNozzleItem:

                    for connector in items[0].connectors:

                        # From

                                connector.connectedItem not in items:

                            for _attr in _attrs:

                                    _attr.AssocItem = connector.connectedItem

                                    break

                            break

                if type(items[-1]) is QEngineeringNozzleItem:

                    for connector in items[-1].connectors:

                        # To

                                connector.connectedItem not in items:

                            for _attr in _attrs:

                                    _attr.AssocItem = connector.connectedItem

                                    break

                            break

        return node

        """convert text item to svg"""

        from xml.etree.ElementTree import Element, SubElement, dump, ElementTree

        try:

        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)

    def findOwner(self, symbols):

        import math

        return item

        """convert symbol svg item to svg"""

        from xml.etree.ElementTree import Element, SubElement, dump, ElementTree

        try:

            node = Element('g')

            node.attrib['ID'] = str(self.uid)

            node.attrib['class'] = self.name

            trans = self.sceneTransform()

            node.attrib['transform'] = f"matrix(" \

                                       f"{trans.m11()},{trans.m12()}," \

                path.attrib['d'] = node_list.item(at).attributes().namedItem('d').nodeValue()

                path.attrib['transform'] = self._document.elementsByTagName('g').item(0).attributes().namedItem('transform').nodeValue()

                node.append(path)

        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)

    '''

        @brief      create item corresponding to given type

    '''

    def setColor(self, color):

    def getColor(self):

        """ return hover color if mouse is over otherwise reutrn owner's color if owner exist else this color """