HYTOS

                rows = cursor.fetchall()

                for row in rows:

                    attr = SymbolAttr()

                    attr.Attribute = row[1]

                    attr.DisplayAttribute = row[2]

                    attr.AttributeType = row[3]

            for component in [component for component in components if component['Name'] == 'Trim Line NO' and component['SymbolType_UID'] == -1]:

                tracer_line_no = QEngineeringTrimLineNoTextItem()

                runs = app_doc_data.get_pipe_runs(str(tracer_line_no.uid))

                if not runs: continue

            for component in [component for component in components if component['Name'] == 'Trim Line NO' and component['SymbolType_UID'] == -1]:

                line_no = QEngineeringTrimLineNoTextItem()

                runs = app_doc_data.get_pipe_runs(str(line_no.uid))

                if not runs: continue

            for trimLineNo in root.iter('TRIM_LINE_NO'):

                line_no = QEngineeringTrimLineNoTextItem()

                run = trimLineNo.find('RUN')

                if run is not None:

    Owner                VARCHAR (37),

	[From] 				[varchar](37) NULL,

	[To] 				[varchar](37) NULL,

    [Supplied By]        TEXT,

    SpecialItemTypes_UID VARCHAR (37) REFERENCES SpecialItemTypes (UID),

	[Freeze] [int] NULL,

CREATE TABLE NOTE_DATA_LIST (

    UID         VARCHAR (37),

    DESCRIPTION TEXT,

    PNID_NO     VARCHAR(256) NOT NULL,

    CONSTRAINT NOTE_DATA_LIST_PK PRIMARY KEY (

        QGraphicsEllipseItem.__init__(self, parent)

        self.parent = parent

        self.buildItem()

        self._direction = 'AUTO'

            connectPointStr = [record['X'], record['Y']]

            sceneConnectPointStr = [record['X'], record['Y']]

            self.connectPoint = (float(connectPointStr[0]), float(connectPointStr[1]))

            self.sceneConnectPoint = (float(sceneConnectPointStr[0]), float(sceneConnectPointStr[1]))

        import uuid

        try:

            if 'CONNECTED_AT' in node.attrib:

                self._connected_at = QEngineeringAbstractItem.CONNECTED_AT_PT if node.attrib['CONNECTED_AT'] == '0' else QEngineeringAbstractItem.CONNECTED_AT_BODY

            connectPointStr = node.find('CONNECTPOINT').text.split(',')

            sceneConnectPointStr = node.find('SCENECONNECTPOINT').text.split(',')

            self.connectPoint = (float(connectPointStr[0]), float(connectPointStr[1]))

            self.sceneConnectPoint = (float(sceneConnectPointStr[0]), float(sceneConnectPointStr[1]))

            QGraphicsLineItem.__init__(self, parent)

            QEngineeringAbstractItem.__init__(self)

            self.thickness = thickness

            self.setPen(QPen(Qt.blue, 4, Qt.SolidLine)) # set default pen

        try:

            uidNode = component['UID']

            uid = uidNode if uidNode is not None else uuid.uuid4() # generate UUID

            app_doc_data = AppDocData.instance()

            connectors = app_doc_data.get_component_connectors(uid)

        try:

            uidNode = node.find('UID')

            uid = uidNode.text if uidNode is not None else uuid.uuid4() # generate UUID

            startPoint = [float(x) for x in node.find('STARTPOINT').text.split(',')]

            endPoint = [float(x) for x in node.find('ENDPOINT').text.split(',')]

                    attr = SymbolAttr.from_record(_attr)

                    item.attrs[attr] = _attr['Value']

                item.loc = [x, y]

                item.size = (width, height)

                item.angle = angle

                    attr = SymbolAttr.fromXml(attr_node)

                    item.attrs[attr] = attr_node.text

                item.loc = [x, y]

                item.size = (width, height)

                item.angle = angle

        QGraphicsTextItem.__init__(self, parent)

        QEngineeringAbstractItem.__init__(self)

        self.type = 'TEXT'

        self.loc = None

        self.size = None

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

            if item is not None:

                item.setVisible(False)

                item.loc = [x, y]

                item.size = [width, height]

                item.angle = angle

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

                if component['Owner'] and component['Owner'] != 'None':

                ## assign area

                if not component['Area']:

                item.setVisible(False)

                if node.find('OWNER') is not None and node.find('OWNER').text != 'None':

            ## assign area

            if item is not None:

        QGraphicsPolygonItem.__init__(self, polygon, parent)

        QEngineeringAbstractItem.__init__(self)

        self.points = points

        self.isEntered = False

            QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemIsFocusable | QGraphicsItem.ItemSendsGeometryChanges)

        self.dbUid = None  # symbol UID

        self.name = ''

        self.type = ''

        self.angle = 0

                                item.attrs[_attr] = [attr.text.split(',')[0], attr.text.split(',')[1]]

                            else:

                                ## for old spec break item that has not uid currectly, may not necessary new data

                                ## up to here 3

                                item.attrs[_attr] = attr.text

                            '''

            item = SymbolSvgItem(path, uid, flip=flip)

        if owner is not None:

        return item

    def __init__(self, UID, Attribute, AttributType, Freeze=False, DisplayAttribute=None, Length=None, Expression=None):

        import uuid

        self.Freeze = Freeze

        self.Attribute = Attribute

        self.AttributeType = AttributType

        """ parse record for property """

        import uuid

        self.Freeze = record['Freeze'] == 'True' if record['Freeze'] else False

        self.Attribute = record['Attribute']

        self.AttributeType = record['AttributeType']

        """ parse xml node for property """

        import uuid

        self.Freeze = node.attrib['Freeze'] == 'True' if 'Freeze' in node.attrib else False

        self.Attribute = node.attrib['Attribute']

        self.AttributeType = node.attrib['AttributeType']

        False

        """

        try:

        except:

            return False

        if self.AttributeType == 'Boolean':

            return True if text and text == 'True' else False

        else:

    def toXml(self):

        """ generate xml code for symbol property """

        import uuid

        attr = SymbolAttr()

        attr.Freeze = record['Freeze'] == 'True' if record['Freeze'] else False

        attr.Attribute = record['Attribute']

        attr.DisplayAttribute = record['DisplayAttribute']

        attr.Expression = record['Expression']

        attr.Length = record['Length'] if 'Length' in record else 0

        attr.IsProp = int(record['Property']) if record['Property'] else 0

        return attr

        import uuid

        attr = SymbolAttr()

        attr.Freeze = node.attrib['Freeze'] == 'True' if 'Freeze' in node.attrib else False

        attr.Attribute = node.attrib['Attribute']

        attr.DisplayAttribute = node.attrib['DisplayAttribute']

        attr.AttrAt = node.attrib['AttrAt']

        attr.Expression = node.attrib['Expression']

        attr.Length = node.attrib['Length']

        return attr

        import uuid

        try:

        except:

            return False