HYTOS

sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), 'Commands'))

from AutoSaveCommand import AutoSaveCommand

            cmd = AutoSaveCommand()

    def request_upload_training_data(self, project_name, tiles, xmls) -> bool:

            data = {'name': project_name, 'count': len(tiles) + len(xmls), 'tiles': [], 'xmls': []}

                    data['xmls'].append((os.path.basename(xml), rects))

            return data['count'] == count

        return False

        """request symbol training on server"""

            data = {'name': name, 'classes': classes, 'bigs': bigs}

            return count == 1

        return False

# coding: utf-8

""" This is SaveWork command module """

import os.path

import sys

from enum import Enum

from PyQt5.QtCore import *

from SingletonInstance import SingletonInstance

class AutoSaveCommand(SingletonInstance):

    display_message = pyqtSignal(Enum, str)

    show_progress = pyqtSignal(int)

    def __init__(self, interval=60000):

        self._interval = interval

        self.timer = QTimer()

        self.timer.timeout.connect(self.save)

        self.timer.start(interval)

    def save(self):

        """save"""

        pass

# coding: utf-8

""" This is Shape module """

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

class Line:

    def __init__(self, start: complex, end: complex):

        self.start = start

        self.end = end

    def to_xml(self):

        xml = Element('Line')

        presentation_node = SubElement(xml, 'Presentation')

        presentation_node.attrib['Layer'] = '125'

        presentation_node.attrib['Color'] = '0'

        presentation_node.attrib['LineType'] = '1'

        presentation_node.attrib['LineWeight'] = '0.35'

        presentation_node.attrib['R'] = '0'

        presentation_node.attrib['G'] = '0'

        presentation_node.attrib['B'] = '0'

        extent_node = SubElement(xml, 'Extent')

        min_node = SubElement(extent_node, 'Min')

        min_node.attrib['X'] = str(min(self.start.real, self.end.real))

        min_node.attrib['Y'] = str(min(self.start.imag, self.end.imag))

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

        max_node = SubElement(extent_node, 'Max')

        max_node.attrib['X'] = str(max(self.start.real, self.end.real))

        max_node.attrib['Y'] = str(max(self.start.imag, self.end.imag))

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

        coordinate_node = SubElement(xml, 'Coordinate')

        coordinate_node.attrib['X'] = str(self.start.real)

        coordinate_node.attrib['Y'] = str(self.start.imag)

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

        coordinate_node = SubElement(xml, 'Coordinate')

        coordinate_node.attrib['X'] = str(self.end.real)

        coordinate_node.attrib['Y'] = str(self.end.imag)

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

        return xml

class GenericAttributes:

    def __init__(self, item):

        self.item = item

        pass

    def to_xml(self):

        xml = Element('GenericAttributes')

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

        attrs = self.item.getAttributes()

        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'] = key.AttributeType

        return xml

class ConnectionPoints:

    def __init__(self, connectors):

        self.connectors = connectors

    def to_xml(self):

        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'] = str(conn.uid)

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

            position_node = SubElement(node, 'Position')

            location_node = SubElement(position_node, 'Location')

            location_node.attrib['X'] = str(conn.center()[0])

            location_node.attrib['Y'] = str(conn.center()[1])

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

            axis_node = SubElement(position_node, 'Axis')

            axis_node.attrib['X'] = '0'

            axis_node.attrib['Y'] = '0'

            axis_node.attrib['Z'] = '1'

            reference_node = SubElement(position_node, 'Reference')

            reference_node.attrib['X'] = '1'

            reference_node.attrib['Y'] = '0'

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

        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

"""imports"""

from PyQt5.QtWidgets import *

def scene_to_dexpi(path, name, scene: QGraphicsScene) -> None:

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

    from .formatter import Formatter

    formatter = Formatter()

    data = formatter.to_dexpi(name, scene)

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

# coding: utf-8

""" This is DEXPI formatter module """

import sys

import os

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

from PyQt5.QtWidgets import *

sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), '..\\Shapes'))

class Formatter:

    PlantModel = 'PlantModel'

    PlantInformation = 'PlantInformation'

    def __init__(self):

        pass

    def to_dexpi(self, name: str, scene: QGraphicsScene):

        """convert all items in scene to dexpi format"""

        from datetime import date, datetime

        def formatter(item):

            pass

        def extent_node(parent, scene):

            extent = SubElement(parent, 'Extent')

            rect = scene.itemsBoundingRect()

            _min = SubElement(extent, 'Min')

            _min.attrib['X'] = str(int(rect.left()))

            _min.attrib['Y'] = str(int(rect.top()))

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

            _max = SubElement(extent, 'Max')

            _max.attrib['X'] = str(int(rect.right()))

            _max.attrib['Y'] = str(int(rect.bottom()))

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

            return extent

        def drawing(name, parent, scene: QGraphicsScene):

            _drawing = SubElement(parent, 'Drawing')

            _drawing.attrib['Name'] = name

            _drawing.attrib['Type'] = 'PID'

            _drawing.attrib['Title'] = ''

            presentation = SubElement(_drawing, 'Presentation')

            presentation.attrib['Layer'] = ''

            presentation.attrib['Color'] = '16777215'

            presentation.attrib['LineType'] = ''

            presentation.attrib['LineWeight'] = ''

            presentation.attrib['R'] = '1.000'

            presentation.attrib['G'] = '1.000'

            presentation.attrib['B'] = '1.000'

            extent = extent_node(_drawing, scene)

            return _drawing

        def shape_catalogue_node(parent, scene):

            from SymbolSvgItem import SymbolSvgItem

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

            from svg.path.path import Move

            from .Shape import Line as DEXPI_Line, ConnectionPoints, GenericAttributes

            node = SubElement(parent, 'ShapeCatalogue')

            node.attrib['Name'] = 'ShapeCatalogue'

            catalogue = set()

            items = [item for item in scene.items() if issubclass(type(item), SymbolSvgItem)]

            for item in items:

                type_str = f"{item.type}/{item.name}"

                if type_str not in catalogue:

                    shape_node = SubElement(node, 'Nozzle' if item.type == 'Nozzles' else 'Equipment')

                    shape_node.attrib['ComponentClass'] = item.type

                    shape_node.attrib['ComponentName'] = item.name

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

                    presentation_node = SubElement(shape_node, 'Presentation')

                    presentation_node.attrib['Layer'] = '0'

                    presentation_node.attrib['Color'] = '0'

                    presentation_node.attrib['LineType'] = '0'

                    presentation_node.attrib['LineWeight'] = '0.1'

                    presentation_node.attrib['R'] = '0'

                    presentation_node.attrib['G'] = '0'

                    presentation_node.attrib['B'] = '0'

                    generic_attributes = GenericAttributes(item)

                    shape_node.append(generic_attributes.to_xml())

                    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:

                                pass

                            elif type(ele) is Line:

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

                                shape_node.append(line.to_xml())

                            elif type(ele) is Arc:

                                pass

                            elif type(ele) is CubicBezier:

                                pass

                            elif type(ele) is QuadraticBezier:

                                pass

                    connection_points_node = ConnectionPoints(item.connectors)

                    shape_node.append(connection_points_node.to_xml())

                    catalogue.add(type_str)

            return node

        def equipment(parent):

            pass

        def piping_network_system(parent):

            pass

        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'] = 'Comos'

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

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

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

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

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

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

        xml.append(node)

        extent = extent_node(xml, scene)

        """drawing"""

        drawing_node = drawing(name, xml, scene)

        shape_catalogue_node = shape_catalogue_node(xml, scene)

        equipment_node = equipment(xml)

        piping_network_system_node = piping_network_system(xml)

        for item in scene.items():

            formatter(item)

        return xml

            elif event.key() == Qt.Key_F6:

                from DEXPI import scene_to_dexpi

                app_doc_data = AppDocData.instance()

                scene_to_dexpi('D:\\Temp\\DEXPI.xml', app_doc_data.activeDrawing.name, self.graphicsView.scene())

    def add_predata_to_scene(self, drawing, scene, symbol: bool, text: bool, line: bool, unknown: bool, package: bool) \

            -> None:

        """add predata to scene"""

            from App import App

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

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

        """clear scenes"""

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

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

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

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

    """This is EmittingStream class"""

# from app.training.index import training_service

# app.register_blueprint(training_service)

        return jsonify({'count': 1})