HYTOS

from .Shape import Point, Line as DEXPI_Line, ConnectionPoints, GenericAttributes, BsplineCurve

    ITEMS = 0

        import sys

        from svg.path import Path, Line, Arc, CubicBezier, QuadraticBezier, parse_path

        from svg.path.path import Move

        try:

            node = Element('Equipment')

            node.attrib['ID'] = f"XME_{Equipment.ITEMS}"

            Equipment.ITEMS += 1

            node.attrib['TagName'] = item.tag_no if item.tag_no else ''

            node.attrib['ComponentClass'] = ''

            node.attrib['ComponentName'] = ''

            node.attrib['ComponentType'] = 'Explicit'

            node.attrib['Status'] = 'Current'

            Presentation.to_xml(node, layer='0', color='0', line_type='0', line_weight=0.1, r=0, g=0, b=0)

            Extent.to_xml(node, item=item)

            _node = SubElement(node, 'Position')

            pt = item.pos()

            _node.append(Point.to_xml('Location', pt.x(), pt.y()))

            _node.append(Point.to_xml('Axis', 0, 0, 1))

            _node.append(Point.to_xml('Reference', 1, 0, 0))

            node.append(Point.to_xml('Scale', 1, 1, 1))

            _node = SubElement(node, 'PersistentID')

            _node.attrib['Identifier'] = str(item.uid)

            _node.attrib['Context'] = 'ID2'

            svg = item.to_svg(parent=None)

            paths = svg[0].findall('path')

            for path in paths:

                path_ele = parse_path(path.attrib['d'])

                for idx, ele in enumerate(path_ele):

                    if type(ele) is Move:

                        continue

                    elif type(ele) is Line:

                        line = DEXPI_Line(ele.start, ele.end)

                        node.append(line.to_xml())

                    elif type(ele) is Arc:

                        continue

                    elif type(ele) is CubicBezier:

                        bspline_curve_node = BsplineCurve.to_xml(controls=[ele.start, ele.control1,

                                                                           ele.control2, ele.end],

                                                                 _type='BsplineCurve', knots=[])

                        node.append(bspline_curve_node)

                    elif type(ele) is QuadraticBezier:

                        continue

                    else:

                        continue

            generic_attributes = GenericAttributes(item)

            _attr_node = generic_attributes.to_xml()

            if _attr_node:

                node.append(_attr_node)

            connection_points_node = ConnectionPoints(item.connectors)

            _conn_node = connection_points_node.to_xml()

            if _conn_node:

                node.append(_conn_node)

            return node

        except Exception as ex:

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

            print(message)

        node.attrib['ComponentType'] = 'Explicit'

# coding: utf-8

""" This is PipingNetworkSystem module """

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

from PyQt5.QtWidgets import *

from .Extent import Extent

from .Shape import Point

from .Presentation import Presentation

class PipingNetworkSegment:

    ITEMS = 0

    def __init__(self):

        pass

    @staticmethod

    def to_xml(parent: Element, run) -> Element:

        """return element for PipingNetworkSegment"""

        from EngineeringLineItem import QEngineeringLineItem

        node = SubElement(parent, 'PipingNetworkSegment')

        node.attrib['ID'] = f"XNG_{PipingNetworkSegment.ITEMS}"

        PipingNetworkSegment.ITEMS += 1

        node.attrib['TagName'] = 'Z001'  #TODO:

        node.attrib['ComponentClass'] = 'PipeSection'

        node.attrib['Status'] = 'Current'

        for item in run.items:

            if type(item) is QEngineeringLineItem:

                PipingNetworkSegment.line_to_xml(node, item)

        return node

    @staticmethod

    def line_to_xml(parent: Element, line) -> Element:

        """return element for CenterLine"""

        node = SubElement(parent, 'CenterLine')

        node.attrib['NumPoints'] = '2'

        Presentation.to_xml(node, layer='20', color='0', line_type='1', line_weight=0.5, r=0, g=0, b=0)

        Extent.to_xml(node, line)

        x, y = line.start_point()[0], line.start_point()[1]

        node.append(Point.to_xml('Coordinate', x=x, y=y))

        x, y = line.end_point()[0], line.end_point()[1]

        node.append(Point.to_xml('Coordinate', x=x, y=y))

        return node

# coding: utf-8

""" This is PipingNetworkSystem module """

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

from PyQt5.QtWidgets import *

from .Extent import Extent

from .PipingNetworkSegment import PipingNetworkSegment

class PipingNetworkSystem:

    ITEMS = 0

    def __init__(self):

        pass

    @staticmethod

    def to_xml(parent: Element, line_no) -> Element:

        """return element for PipingNetworkSystem"""

        node = SubElement(parent, 'PipingNetworkSystem')

        node.attrib['ID'] = f"XNS_{PipingNetworkSystem.ITEMS}"

        PipingNetworkSystem.ITEMS += 1

        node.attrib['TagName'] = line_no.text()

        node.attrib['ComponentClass'] = 'Pipe'

        node.attrib['Status'] = 'Current'

        for run in line_no.runs:

            PipingNetworkSegment.to_xml(node, run)

        return node

        if _type == 'BsplineCurveWithKnots':

            node.attrib['NumKnots'] = f"{len(knots)}"

        Presentation.to_xml(node, layer="", color="-32363", r=0.67, g=0.38, b=0)

        min_x = min([control.real for control in controls])

        max_x = max([control.real for control in controls])

        min_y = min([control.imag for control in controls])

        max_y = max([control.imag for control in controls])

        _extent_node = SubElement(node, 'Extent')

        _min_node = SubElement(_extent_node, 'Min')

        _min_node.attrib['X'] = str(min_x)

        _min_node.attrib['Y'] = str(min_y)

        _min_node.attrib['Z'] = '0'

        _max_node = SubElement(_extent_node, 'Max')

        _max_node.attrib['X'] = str(max_x)

        _max_node.attrib['Y'] = str(max_y)

        _max_node.attrib['Z'] = '0'

        if _type == 'BsplineCurveWithKnots':

            knots_node = SubElement(node, 'Knots')

            for knot in knots:

                knot_node = SubElement(knots_node, 'Knot')

                knot_node.text = f"{knot}"

        if attrs:

            xml = Element('GenericAttributes')

            xml.attrib['Set'] = 'ID2Properties'

            xml.attrib['Number'] = str(len(attrs))

            for key, value in attrs.items():

                generic_attribute_node = SubElement(xml, 'GenericAttribute')

                generic_attribute_node.attrib['Name'] = key.Attribute

                generic_attribute_node.attrib['Value'] = value if value else ''

                generic_attribute_node.attrib['Format'] = 'string'  # key.AttributeType

            return xml

        return None

    NODES = 0

        if self.connectors:

            xml = Element('ConnectionPoints')

            xml.attrib['NumPoints'] = str(len(self.connectors))

            min_x, min_y = None, None

            max_x, max_y = None, None

            for conn in self.connectors:

                center = conn.center()

                min_x = center[0] if min_x is None or min_x > center[0] else min_x

                max_x = center[0] if max_x is None or max_x < center[0] else max_x

                min_y = center[1] if min_y is None or min_y > center[1] else min_y

                max_y = center[1] if max_y is None or max_y < center[1] else max_y

            extent_node = SubElement(xml, 'Extent')

            min_node = SubElement(extent_node, 'Min')

            min_node.attrib['X'] = str(min_x)

            min_node.attrib['Y'] = str(min_y)

            min_node.attrib['Z'] = '0'

            max_node = SubElement(extent_node, 'Max')

            max_node.attrib['X'] = str(max_x)

            max_node.attrib['Y'] = str(max_y)

            max_node.attrib['Z'] = '0'

            for idx, conn in enumerate(self.connectors):

                node = SubElement(xml, 'Node')

                node.attrib['ID'] = f"XMP_{ConnectionPoints.NODES}"

                node.attrib['Name'] = f"conn{idx}"

                position_node = SubElement(node, 'Position')

                location_node = Point.to_xml('Location', x=conn.center()[0], y=conn.center()[1], z=0)

                position_node.append(location_node)

                axis_node = Point.to_xml('Axis', x=0, y=0, z=1)

                position_node.append(axis_node)

                reference_node = Point.to_xml('Reference', x=1, y=0, z=0)

                position_node.append(reference_node)

                ConnectionPoints.NODES += 1

            generic_attributes_node = SubElement(xml, 'GenericAttributes')

            generic_attributes_node.attrib['Number'] = str(len(self.connectors))

            for idx in range(len(self.connectors)):

                generic_attribute_node = SubElement(generic_attributes_node, 'GenericAttribute')

                generic_attribute_node.attrib['Name'] = f"NodeName{idx}"

                generic_attribute_node.attrib['Value'] = f"conn{idx}"

                generic_attribute_node.attrib['Format'] = 'string'

            return xml

        return None

    ITEMS = 0

                shape_node.attrib['ID'] = f"XMC_{ShapeCatalogue.ITEMS}"

                _attr_node = generic_attributes.to_xml()

                if _attr_node:

                    shape_node.append(_attr_node)

                """

                                                                     _type='BsplineCurve', knots=[])

                """

                ShapeCatalogue.ITEMS += 1

                _conn_node = connection_points_node.to_xml()

                if _conn_node:

                    shape_node.append(_conn_node)

    import sys

    try:

        formatter = Formatter()

        data = formatter.to_dexpi(name, scene)

        ElementTree(data).write(path, encoding='utf-8', xml_declaration=True)

    except Exception as ex:

        message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                  f"{sys.exc_info()[-1].tb_lineno}"

        print(message)

from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

from .PipingNetworkSystem import PipingNetworkSystem

        try:

            today = date.today()

            xml = Element(Formatter.PlantModel)  # Root Node

            xml.attrib['xmlns:xsi'] = 'http://www.w3.org/2001/XMLSchema-instance'

            xml.attrib['xsi:noNamespaceSchemaLocation'] = 'XMpLantPIDProfileSchema_4.0.1.xsd'

            node = Element(Formatter.PlantInformation)

            node.attrib['SchemaVersion'] = '4.0.1'

            node.attrib['OriginatingSystem'] = 'ID2'

            node.attrib['Date'] = today.strftime("%Y-%m-%d")

            node.attrib['Time'] = datetime.now().strftime('%H:%M:%S')

            node.attrib['Is3D'] = 'no'

            node.attrib['Units'] = 'mm'

            node.attrib['Discipline'] = 'PID'

            SubElement(node, 'UnitsOfMeasure').attrib['Distance'] = 'Millimetre'

            extent = Extent.to_xml(xml, scene=scene)

            """drawing node"""

            drawing_node = Drawing.to_xml(name, scene)

            xml.append(drawing_node)

            """shape catalogue node"""

            shape_catalogue_node = ShapeCatalogue.to_xml(scene)

            xml.append(shape_catalogue_node)

            """equipment nodes"""

            equipments = [item for item in scene.items() if type(item) is QEngineeringEquipmentItem]

            for equipment in equipments:

                node = Equipment.to_xml(equipment)

                xml.append(node)

            """piping network system"""

            line_nos = [item for item in scene.items() if type(item) is QEngineeringLineNoTextItem]

            for line_no in line_nos:

                PipingNetworkSystem.to_xml(xml, line_no)

            for item in scene.items():

                formatter(item)

            return xml

        except Exception as ex:

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

            print(message)