HYTOS

# coding: utf-8

""" This is Symbol Attribute module """

class SymbolProp:

    """ This is symbol property class """

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

        import uuid

        self.UID = uuid.uuid4() if UID is None else uuid.UUID(UID)

        self.Freeze = Freeze

        self.Attribute = Attribute

        self.AttributeType = AttributType

        self.DisplayAttribute = DisplayAttribute if DisplayAttribute else Attribute

        self.Length = Length 

        self.Expression = Expression 

    @property

    def is_selectable(self):

        """ return if attribute is selectable """

        from SymbolAttrEditorDialog import QSymbolAttrEditorDialog

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

    def match_type(self, item):

        """ check if given item's attribute type matches """

        from EngineeringAbstractItem import QEngineeringAbstractItem

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringLineItem import QEngineeringLineItem

        if self.AttributeType == 'Comp Item':

            return issubclass(type(item), SymbolSvgItem) or type(item) is QEngineeringLineItem

        elif self.AttributeType == QEngineeringAbstractItem.assoc_type(item):

            return True

        return False

    def parse_record(self, record):

        """ parse record for property """

        import uuid

        self.UID = uuid.UUID(record['UID'])

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

        self.Attribute = record['Attribute']

        self.AttributeType = record['AttributeType']

        self.DisplayAttribute = record['DisplayAttribute']

        self.Expression = record['Expression']

        self.Length = record['Length']

    def parse_xml(self, node):

        """ parse xml node for property """

        import uuid

        self.UID = uuid.UUID(node.attrib['UID'])

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

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

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

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

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

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

    @staticmethod

    def is_valid_uuid(value, version=4):

        import uuid

        """

        Check if uuid_to_test is a valid UUID.

        Parameters

        ----------

        uuid_to_test : str

        version : {1, 2, 3, 4}

        Returns

        -------

        `True` if uuid_to_test is a valid UUID, otherwise `False`.

        Examples

        --------

        >>> is_valid_uuid('c9bf9e57-1685-4c89-bafb-ff5af830be8a')

        True

        >>> is_valid_uuid('c9bf9e58')

        False

        """

        try:

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

        except:

            return False

        return str(uuid_obj) == value 

    def parse_value(self, text):

        """ parse value of property """

        import uuid

        if self.AttributeType == 'Boolean':

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

        else:

            return uuid.UUID(text) if text and SymbolProp.is_valid_uuid(text) else text if text else ''

    def toXml(self):

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

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

        node = Element('PROPERTY')

        node.attrib['UID'] = str(self.UID) if self.UID else ''

        node.attrib['Freeze'] = str(self.Freeze)

        node.attrib['Attribute'] = self.Attribute if self.Attribute is not None else ''

        node.attrib['AttributeType'] = self.AttributeType if self.AttributeType is not None else ''

        node.attrib['DisplayAttribute'] = self.DisplayAttribute if self.DisplayAttribute else ''

        node.attrib['Expression'] = self.Expression if self.Expression else ''

        node.attrib['Length'] = str(self.Length) if self.Length else ''

        return node

class SymbolAttr(SymbolProp):

    """ This is symbol attribute class """

    def __init__(self):

        import uuid

        SymbolProp.__init__(self, None, None, None)

        self.UID = uuid.uuid4()

        self.Freeze = False

        self.Attribute = None

        self.DisplayAttribute = None

        self.AttributeType = None

        self.AttrAt = None

        self.Expression = None

        self.Target = None

        self.Length = None

        self.AssocItem = None

        self.IsProp = 0  # default value is 0

        self.Codes = None

    @staticmethod

    def from_record(record):

        """ parse record for property """

        import uuid

        attr = SymbolAttr()

        attr.UID = uuid.UUID(record['UID'])

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

        attr.Attribute = record['Attribute']

        attr.DisplayAttribute = record['DisplayAttribute']

        attr.AttributeType = record['AttributeType']

        attr.AttrAt = record['AttrAt']

        attr.Expression = record['Expression']

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

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

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

        return attr

    @staticmethod

    def fromXml(node):

        """ generate SymbolAttr instance from xml node """

        import uuid

        attr = SymbolAttr()

        attr.UID = uuid.UUID(node.attrib['UID']) if 'UID' in node.attrib and node.attrib['UID'] != '' else uuid.uuid4()

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

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

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

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

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

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

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

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

        return attr

    def toXml(self):

        """ generate xml code for symbol attribute """

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

        node = Element('ATTRIBUTE')

        node.attrib['Freeze'] = str(self.Freeze)

        node.attrib['UID'] = str(self.UID) if self.UID is not None else ''

        node.attrib['Attribute'] = self.Attribute if self.Attribute is not None else ''

        node.attrib['DisplayAttribute'] = self.DisplayAttribute if self.DisplayAttribute is not None else ''

        node.attrib['AttributeType'] = self.AttributeType if self.AttributeType is not None else ''

        node.attrib['AttrAt'] = str(self.AttrAt) if self.AttrAt is not None else ''

        node.attrib['Expression'] = self.Expression if self.Expression is not None else ''

        node.attrib['Length'] = str(self.Length) if self.Length is not None else ''

        node.attrib['AssocItem'] = str(self.AssocItem) if self.AssocItem is not None else ''

        return node