umlio 0.1.0__py3-none-any.whl

umlio/BaseUmlToXml.py

@@ -0,0 +1,43 @@
+
+from umlshapes.types.Common import UmlShape
+from umlshapes.types.UmlDimensions import UmlDimensions
+from umlshapes.types.UmlPosition import UmlPosition
+
+from umlio.IOTypes import ElementAttributes
+from umlio.XMLConstants import XmlConstants
+
+
+class BaseUmlToXml:
+    def __init__(self):
+        pass
+
+    def _umlBaseAttributes(self, umlShape: UmlShape) -> ElementAttributes:
+        """
+        Create the common OglObject attributes
+
+        Args:
+            umlShape:  OGL Object
+
+        Returns:
+            The updated originalElement
+        """
+        umlClassId: str           = str(umlShape.id)
+        size:       UmlDimensions = umlShape.size
+        position:   UmlPosition   = umlShape.position
+
+        w: int = size.width
+        h: int = size.height
+        x: int = position.x
+        y: int = position.y
+
+        attributes: ElementAttributes = ElementAttributes(
+            {
+                XmlConstants.ATTRIBUTE_ID:     umlClassId,
+                XmlConstants.ATTRIBUTE_WIDTH:  str(w),
+                XmlConstants.ATTRIBUTE_HEIGHT: str(h),
+                XmlConstants.ATTRIBUTE_X:      str(x),
+                XmlConstants.ATTRIBUTE_Y:      str(y),
+            }
+        )
+
+        return attributes

umlio/IOTypes.py

@@ -0,0 +1,98 @@
+
+from typing import Dict
+from typing import List
+from typing import NewType
+
+from enum import Enum
+
+from dataclasses import dataclass
+from dataclasses import field
+
+from pathlib import Path
+
+from umlshapes.shapes.UmlActor import UmlActor
+from umlshapes.shapes.UmlClass import UmlClass
+from umlshapes.shapes.UmlNote import UmlNote
+from umlshapes.shapes.UmlText import UmlText
+from umlshapes.shapes.UmlUseCase import UmlUseCase
+
+from umlshapes.links.UmlLink import UmlLink
+
+UML_VERSION: str = '12.0'
+
+UmlDiagramTitle = NewType('UmlDiagramTitle', str)
+UmlClasses      = NewType('UmlClasses',      List[UmlClass])
+UmlUseCases     = NewType('UmlUseCases',     List[UmlUseCase])
+UmlActors       = NewType('UmlActors',       List[UmlActor])
+UmlNotes        = NewType('UmlNotes',        List[UmlNote])
+UmlTexts        = NewType('UmlTexts',        List[UmlText])
+UmlLinks        = NewType('UmlLinks',        List[UmlLink])
+
+ElementAttributes = NewType('ElementAttributes', Dict[str, str])
+
+
+class UmlDiagramType(Enum):
+    CLASS_DIAGRAM    = 'Class Diagram'
+    USE_CASE_DIAGRAM = 'Use Case Diagram'
+    SEQUENCE_DIAGRAM = 'Sequence Diagram'
+    NOT_SET          = 'Not Set'
+
+
+def umlClassesFactory() -> UmlClasses:
+    """
+    Factory method to create  the UmlClasses data structure;
+
+    Returns:  A new data structure
+    """
+    return UmlClasses([])
+
+
+def umlUseCasesFactory() -> UmlUseCases:
+    return UmlUseCases([])
+
+
+def umlActorsFactory() -> UmlActors:
+    return UmlActors([])
+
+
+def umlNotesFactory() -> UmlNotes:
+    return UmlNotes([])
+
+
+def umlTextsFactory() -> UmlTexts:
+    return UmlTexts([])
+
+
+def umlLinksFactory() -> UmlLinks:
+    return UmlLinks([])
+
+
+@dataclass
+class UmlDiagram:
+    diagramType:     UmlDiagramType  = UmlDiagramType.NOT_SET
+    diagramTitle:    UmlDiagramTitle = UmlDiagramTitle('')
+    scrollPositionX: int = 1
+    scrollPositionY: int = 1
+    pixelsPerUnitX:  int = 1
+    pixelsPerUnitY:  int = 1
+    umlClasses:      UmlClasses  = field(default_factory=umlClassesFactory)
+    umlUseCases:     UmlUseCases = field(default_factory=umlUseCasesFactory)
+    umlActors:       UmlActors   = field(default_factory=umlActorsFactory)
+    umlNotes:        UmlNotes    = field(default_factory=umlNotesFactory)
+    umlTexts:        UmlTexts    = field(default_factory=umlTextsFactory)
+    umlLinks:        UmlLinks    = field(default_factory=umlLinksFactory)
+
+
+UmlDiagrams = NewType('UmlDiagrams', Dict[UmlDiagramTitle, UmlDiagram])
+
+
+def createUmlDiagramsFactory() -> UmlDiagrams:
+    return UmlDiagrams({})
+
+
+@dataclass
+class UmlProject:
+    fileName:    str  = ''
+    version:     str  = UML_VERSION
+    codePath:    Path = Path('')
+    umlDiagrams: UmlDiagrams = field(default_factory=createUmlDiagramsFactory)

umlio/PyutToXml.py

@@ -0,0 +1,349 @@
+
+from logging import Logger
+from logging import getLogger
+
+from os import linesep as osLineSep
+
+from xml.etree.ElementTree import Element
+from xml.etree.ElementTree import SubElement
+
+from codeallybasic.Common import XML_END_OF_LINE_MARKER
+
+from umlio.IOTypes import ElementAttributes
+
+from pyutmodelv2.PyutLink import LinkDestination
+from pyutmodelv2.PyutLink import LinkSource
+from pyutmodelv2.PyutLink import PyutLink
+
+from pyutmodelv2.PyutModelTypes import ClassName
+from pyutmodelv2.PyutActor import PyutActor
+from pyutmodelv2.PyutClass import PyutClass
+from pyutmodelv2.PyutClassCommon import PyutClassCommon
+from pyutmodelv2.PyutField import PyutField
+from pyutmodelv2.PyutInterface import PyutInterface
+from pyutmodelv2.PyutMethod import PyutMethod
+from pyutmodelv2.PyutMethod import SourceCode
+from pyutmodelv2.PyutNote import PyutNote
+from pyutmodelv2.PyutParameter import PyutParameter
+from pyutmodelv2.PyutSDInstance import PyutSDInstance
+from pyutmodelv2.PyutSDMessage import PyutSDMessage
+from pyutmodelv2.PyutText import PyutText
+from pyutmodelv2.PyutUseCase import PyutUseCase
+
+from umlio.XMLConstants import XmlConstants
+
+
+class PyutToXml:
+    """
+    Serializes Pyut Model classes to DOM
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.logger: Logger = getLogger(__name__)
+
+    def pyutClassToXml(self, pyutClass: PyutClass, graphicElement: Element) -> Element:
+        """
+        Exporting a PyutClass to a miniDom Element.
+
+        Args:
+            pyutClass:       The pyut class to serialize
+            graphicElement:  The xml element to update
+
+        Returns:
+            A new updated element
+        """
+
+        commonAttributes = self._pyutClassCommonAttributes(pyutClass)
+        attributes = {
+            XmlConstants.ATTRIBUTE_ID:                     str(pyutClass.id),
+            XmlConstants.ATTRIBUTE_NAME:                   pyutClass.name,
+            XmlConstants.ATTRIBUTE_DISPLAY_METHODS:        str(pyutClass.showMethods),
+            XmlConstants.ATTRIBUTE_DISPLAY_PARAMETERS:     pyutClass.displayParameters.value,
+            XmlConstants.ATTRIBUTE_DISPLAY_CONSTRUCTOR:    pyutClass.displayConstructor.value,
+            XmlConstants.ATTRIBUTE_DISPLAY_DUNDER_METHODS: pyutClass.displayDunderMethods.value,
+            XmlConstants.ATTRIBUTE_DISPLAY_FIELDS:         str(pyutClass.showFields),
+            XmlConstants.ATTRIBUTE_DISPLAY_STEREOTYPE:     str(pyutClass.displayStereoType),
+            XmlConstants.ATTRIBUTE_FILENAME:               pyutClass.fileName,
+        }
+
+        attributes = attributes | commonAttributes
+
+        pyutClassElement: Element = SubElement(graphicElement, XmlConstants.ELEMENT_MODEL_CLASS, attrib=attributes)
+
+        for method in pyutClass.methods:
+            self._pyutMethodToXml(pyutMethod=method, pyutClassElement=pyutClassElement)
+
+        for pyutField in pyutClass.fields:
+            self._pyutFieldToXml(pyutField=pyutField, pyutClassElement=pyutClassElement)
+        return pyutClassElement
+
+    def pyutLinkToXml(self, pyutLink: PyutLink, oglLinkElement: Element) -> Element:
+        """
+        Exporting a PyutLink to an Element.
+
+        Args:
+            pyutLink:   Link to save
+            oglLinkElement:     xml document
+
+        Returns:
+            A new minidom element
+        """
+        src: LinkSource      = pyutLink.source
+        dst: LinkDestination = pyutLink.destination
+
+        srcLinkId:  int = src.id
+        destLinkId: int = dst.id
+
+        attributes: ElementAttributes = ElementAttributes({
+            XmlConstants.ATTRIBUTE_NAME:           pyutLink.name,
+            XmlConstants.ATTRIBUTE_TYPE:           pyutLink.linkType.name,
+            XmlConstants.ATTRIBUTE_SOURCE_ID:      str(srcLinkId),
+            XmlConstants.ATTRIBUTE_DESTINATION_ID: str(destLinkId),
+            XmlConstants.ATTRIBUTE_BIDIRECTIONAL:  str(pyutLink.bidirectional),
+            XmlConstants.ATTRIBUTE_SOURCE_CARDINALITY_VALUE:      pyutLink.sourceCardinality,
+            XmlConstants.ATTRIBUTE_DESTINATION_CARDINALITY_VALUE: pyutLink.destinationCardinality,
+        })
+        pyutLinkElement: Element = SubElement(oglLinkElement, XmlConstants.ELEMENT_MODEL_LINK, attrib=attributes)
+
+        return pyutLinkElement
+
+    def pyutInterfaceToXml(self, pyutInterface: PyutInterface, interface2Element: Element) -> Element:
+
+        classId: int = pyutInterface.id
+
+        attributes: ElementAttributes = ElementAttributes({
+            XmlConstants.ATTRIBUTE_ID:          str(classId),
+            XmlConstants.ATTRIBUTE_NAME:        pyutInterface.name,
+            XmlConstants.ATTRIBUTE_DESCRIPTION: pyutInterface.description
+        })
+        pyutInterfaceElement: Element = SubElement(interface2Element, XmlConstants.ELEMENT_MODEL_INTERFACE, attrib=attributes)
+
+        for method in pyutInterface.methods:
+            self._pyutMethodToXml(pyutMethod=method, pyutClassElement=pyutInterfaceElement)
+
+        for className in pyutInterface.implementors:
+            self.logger.debug(f'implementing className: {className}')
+            self._pyutImplementorToXml(className, pyutInterfaceElement)
+
+        return pyutInterfaceElement
+
+    def pyutNoteToXml(self, pyutNote: PyutNote, oglNoteElement: Element) -> Element:
+
+        noteId:       int = pyutNote.id
+        content:      str = pyutNote.content
+        fixedContent: str  = content.replace(osLineSep, XML_END_OF_LINE_MARKER)
+        if pyutNote.fileName is None:
+            pyutNote.fileName = ''
+
+        attributes: ElementAttributes = ElementAttributes({
+            XmlConstants.ATTRIBUTE_ID:       str(noteId),
+            XmlConstants.ATTRIBUTE_CONTENT:  fixedContent,
+            XmlConstants.ATTRIBUTE_FILENAME: pyutNote.fileName,
+        })
+        pyutNoteElement: Element = SubElement(oglNoteElement, XmlConstants.ELEMENT_MODEL_NOTE, attrib=attributes)
+
+        return pyutNoteElement
+
+    def pyutTextToXml(self, pyutText: PyutText, oglTextElement: Element) -> Element:
+
+        textId:       int = pyutText.id
+        content:      str = pyutText.content
+        fixedContent: str  = content.replace(osLineSep, XML_END_OF_LINE_MARKER)
+
+        attributes: ElementAttributes = ElementAttributes({
+            XmlConstants.ATTRIBUTE_ID:       str(textId),
+            XmlConstants.ATTRIBUTE_CONTENT:  fixedContent,
+        })
+        pyutTextElement: Element = SubElement(oglTextElement, XmlConstants.ELEMENT_MODEL_TEXT, attrib=attributes)
+
+        return pyutTextElement
+
+    def pyutActorToXml(self, pyutActor: PyutActor, oglActorElement: Element) -> Element:
+
+        actorId:  int = pyutActor.id
+        fileName: str = pyutActor.fileName
+        if fileName is None:
+            fileName = ''
+
+        attributes: ElementAttributes = ElementAttributes({
+            XmlConstants.ATTRIBUTE_ID:       str(actorId),
+            XmlConstants.ATTRIBUTE_NAME:     pyutActor.name,
+            XmlConstants.ATTRIBUTE_FILE_NAME: fileName,
+        })
+        pyutActorElement: Element = SubElement(oglActorElement, XmlConstants.ELEMENT_MODEL_ACTOR, attributes)
+
+        return pyutActorElement
+
+    def pyutUseCaseToXml(self, pyutUseCase: PyutUseCase, oglUseCaseElement: Element) -> Element:
+
+        useCaseId: int = pyutUseCase.id
+        fileName:  str = pyutUseCase.fileName
+        if fileName is None:
+            fileName = ''
+
+        attributes: ElementAttributes = ElementAttributes({
+            XmlConstants.ATTRIBUTE_ID:       str(useCaseId),
+            XmlConstants.ATTRIBUTE_NAME:     pyutUseCase.name,
+            XmlConstants.ATTRIBUTE_FILE_NAME: fileName
+        })
+        pyutUseCaseElement: Element = SubElement(oglUseCaseElement, XmlConstants.ELEMENT_MODEL_USE_CASE, attributes)
+
+        return pyutUseCaseElement
+
+    def pyutSDInstanceToXml(self, pyutSDInstance: PyutSDInstance, oglSDInstanceElement: Element) -> Element:
+
+        sdInstanceId: int = pyutSDInstance.id
+
+        attributes: ElementAttributes = ElementAttributes({
+            XmlConstants.ATTRIBUTE_ID:               str(sdInstanceId),
+            XmlConstants.ATTRIBUTE_INSTANCE_NAME:    pyutSDInstance.instanceName,
+            XmlConstants.ATTRIBUTE_LIFE_LINE_LENGTH: str(pyutSDInstance.instanceLifeLineLength),
+        })
+
+        pyutSDInstanceElement: Element = SubElement(oglSDInstanceElement, XmlConstants.ELEMENT_MODEL_SD_INSTANCE, attrib=attributes)
+
+        return pyutSDInstanceElement
+
+    def pyutSDMessageToXml(self, pyutSDMessage: PyutSDMessage, oglSDMessageElement: Element) -> Element:
+
+        sdMessageId: int = pyutSDMessage.id
+
+        # srcInstance: PyutSDInstance = pyutSDMessage.getSource()
+        # dstInstance: PyutSDInstance = pyutSDMessage.getDestination()
+        srcInstance: LinkSource      = pyutSDMessage.source
+        dstInstance: LinkDestination = pyutSDMessage.destination
+
+        idSrc: int = srcInstance.id
+        idDst: int = dstInstance.id
+
+        attributes: ElementAttributes = ElementAttributes({
+            XmlConstants.ATTRIBUTE_ID:                        str(sdMessageId),
+            XmlConstants.ATTRIBUTE_MESSAGE:                   pyutSDMessage.message,
+            XmlConstants.ATTRIBUTE_SOURCE_TIME:               str(pyutSDMessage.sourceY),
+            XmlConstants.ATTRIBUTE_DESTINATION_TIME:          str(pyutSDMessage.destinationY),
+            XmlConstants.ATTRIBUTE_SD_MESSAGE_SOURCE_ID:      str(idSrc),
+            XmlConstants.ATTRIBUTE_SD_MESSAGE_DESTINATION_ID: str(idDst),
+        })
+
+        pyutSDMessageElement: Element = SubElement(oglSDMessageElement, XmlConstants.ELEMENT_MODEL_SD_MESSAGE, attrib=attributes)
+
+        return pyutSDMessageElement
+
+    def _pyutMethodToXml(self, pyutMethod: PyutMethod, pyutClassElement: Element) -> Element:
+        """
+        Exporting a PyutMethod to an Element
+
+        Args:
+            pyutMethod:        Method to serialize
+            pyutClassElement:  xml document
+
+        Returns:
+            The new updated element
+        """
+        attributes = {
+            XmlConstants.ATTRIBUTE_NAME:               pyutMethod.name,
+            XmlConstants.ATTRIBUTE_VISIBILITY:         pyutMethod.visibility.name,
+            XmlConstants.ATTRIBUTE_METHOD_RETURN_TYPE: pyutMethod.returnType.value,
+        }
+        pyutMethodElement: Element = SubElement(pyutClassElement, XmlConstants.ELEMENT_MODEL_METHOD, attrib=attributes)
+        for modifier in pyutMethod.modifiers:
+            attributes = {
+                XmlConstants.ATTRIBUTE_NAME: modifier.name,
+            }
+            SubElement(pyutMethodElement, XmlConstants.ELEMENT_MODEL_MODIFIER, attrib=attributes)
+        self._pyutSourceCodeToXml(pyutMethod.sourceCode, pyutMethodElement)
+
+        for pyutParameter in pyutMethod.parameters:
+            self._pyutParameterToXml(pyutParameter, pyutMethodElement)
+        # pyutMethodElement: Element = xmlDoc.createElement(XmlConstants.ELEMENT_MODEL_METHOD)
+        #
+        # pyutMethodElement.setAttribute(XmlConstants.ATTR_NAME, pyutMethod.name)
+        #
+        # visibility: PyutVisibilityEnum = pyutMethod.getVisibility()
+        # visName:    str                = self.__safeVisibilityToName(visibility)
+        #
+        # if visibility is not None:
+        #     pyutMethodElement.setAttribute(XmlConstants.ATTR_VISIBILITY, visName)
+        #
+        # for modifier in pyutMethod.modifiers:
+        #     xmlModifier: Element = xmlDoc.createElement(XmlConstants.ELEMENT_MODEL_MODIFIER)
+        #     xmlModifier.setAttribute(XmlConstants.ATTR_NAME, modifier.name)
+        #     pyutMethodElement.appendChild(xmlModifier)
+        #
+        # if pyutMethod.returnType is not None:
+        #     xmlReturnType: Element = xmlDoc.createElement(XmlConstants.ELEMENT_MODEL_RETURN)
+        #     xmlReturnType.setAttribute(XmlConstants.ATTR_TYPE, str(pyutMethod.returnType))
+        #     pyutMethodElement.appendChild(xmlReturnType)
+        #
+        # for param in pyutMethod.parameters:
+        #     pyutMethodElement.appendChild(self._pyutParamToDom(param, xmlDoc))
+        #
+        # codeRoot: Element = self._pyutSourceCodeToDom(pyutMethod.sourceCode, xmlDoc)
+        # pyutMethodElement.appendChild(codeRoot)
+        # return pyutMethodElement
+        return pyutMethodElement
+
+    def _pyutClassCommonAttributes(self, classCommon: PyutClassCommon):
+
+        attributes = {
+            XmlConstants.ATTRIBUTE_DESCRIPTION: classCommon.description
+        }
+        return attributes
+
+    def _pyutSourceCodeToXml(self, sourceCode: SourceCode, pyutMethodElement: Element):
+
+        codeRoot: Element = SubElement(pyutMethodElement, XmlConstants.ELEMENT_MODEL_SOURCE_CODE)
+
+        for code in sourceCode:
+            codeElement: Element = SubElement(codeRoot, XmlConstants.ELEMENT_MODEL_CODE)
+            codeElement.text = code
+
+        return codeRoot
+
+    def _pyutParameterToXml(self, pyutParameter: PyutParameter, pyutMethodElement: Element) -> Element:
+
+        attributes = {
+            XmlConstants.ATTRIBUTE_NAME:          pyutParameter.name,
+            XmlConstants.ATTRIBUTE_TYPE:          pyutParameter.type.value,
+            # XmlConstants.ATTR_DEFAULT_VALUE: pyutParameter.defaultValue,
+        }
+
+        defaultValue = pyutParameter.defaultValue
+        if defaultValue is not None:
+            attributes[XmlConstants.ATTRIBUTE_DEFAULT_VALUE] = pyutParameter.defaultValue
+
+        pyutParameterElement: Element = SubElement(pyutMethodElement, XmlConstants.ELEMENT_MODEL_PARAMETER, attrib=attributes)
+
+        return pyutParameterElement
+
+    def _pyutFieldToXml(self, pyutField: PyutField, pyutClassElement: Element) -> Element:
+        """
+        Serialize a PyutField to an Element
+
+        Args:
+            pyutField:         The PyutField to serialize
+            pyutClassElement: The Pyut Class element to update
+
+        Returns:
+            The new updated element
+        """
+        attributes = {
+            XmlConstants.ATTRIBUTE_NAME:          pyutField.name,
+            XmlConstants.ATTRIBUTE_VISIBILITY:    pyutField.visibility.name,
+            XmlConstants.ATTRIBUTE_TYPE:          pyutField.type.value,
+            XmlConstants.ATTRIBUTE_DEFAULT_VALUE: pyutField.defaultValue,
+        }
+        pyutFieldElement: Element = SubElement(pyutClassElement, XmlConstants.ELEMENT_MODEL_FIELD, attrib=attributes)
+
+        return pyutFieldElement
+
+    def _pyutImplementorToXml(self, className: ClassName, xmlDoc: Element) -> Element:
+
+        # root: Element = xmlDoc.createElement(XmlConstants.ELEMENT_IMPLEMENTOR)
+        # root.setAttribute()
+        attributes: ElementAttributes = ElementAttributes({
+            XmlConstants.ATTRIBUTE_IMPLEMENTING_CLASS_NAME: className,
+        })
+        implementorElement: Element = SubElement(xmlDoc, XmlConstants.ELEMENT_MODEL_IMPLEMENTOR, attrib=attributes)
+        return implementorElement

umlio/UmlClassToXml.py

@@ -0,0 +1,47 @@
+
+from logging import Logger
+from logging import getLogger
+
+from xml.etree.ElementTree import Element
+from xml.etree.ElementTree import SubElement
+
+from umlshapes.shapes.UmlClass import UmlClass
+
+from umlio.BaseUmlToXml import BaseUmlToXml
+from umlio.IOTypes import UmlClasses
+from umlio.PyutToXml import PyutToXml
+from umlio.XMLConstants import XmlConstants
+
+
+class UmlClassToXml(BaseUmlToXml):
+    def __init__(self):
+
+        super().__init__()
+
+        self.logger:     Logger    = getLogger(__name__)
+        self._pyutToXml: PyutToXml = PyutToXml()
+
+    def serialize(self, documentTop: Element, umlClasses: UmlClasses) -> Element:
+
+        for umlClass in umlClasses:
+            self._oglClassToXml(documentTop=documentTop, umlClass=umlClass)
+
+        return documentTop
+
+    def _oglClassToXml(self, documentTop: Element, umlClass: UmlClass) -> Element:
+        """
+        Exports an UmlClass to a minidom Element.
+
+        Args:
+            documentTop: The document to append to
+            umlClass:    UML Class to serialize
+
+        Returns:
+            The newly created `UmlClass` Element
+        """
+        attributes = self._umlBaseAttributes(umlShape=umlClass)
+        oglClassSubElement: Element = SubElement(documentTop, XmlConstants.ELEMENT_UML_CLASS, attrib=attributes)
+
+        self._pyutToXml.pyutClassToXml(graphicElement=oglClassSubElement, pyutClass=umlClass.pyutClass)
+
+        return oglClassSubElement

umlio/UmlLinksToXml.py

@@ -0,0 +1,153 @@
+
+from typing import cast
+
+from logging import Logger
+from logging import getLogger
+
+from wx import Point
+
+from xml.etree.ElementTree import Element
+from xml.etree.ElementTree import SubElement
+
+from umlshapes.links.DeltaXY import DeltaXY
+from umlshapes.links.UmlAssociation import UmlAssociation
+from umlshapes.links.UmlAssociationLabel import UmlAssociationLabel
+from umlshapes.links.UmlLink import UmlLink
+from umlshapes.links.eventhandlers.UmlLinkEventHandler import LineControlPoints
+
+from umlshapes.types.Common import EndPoints
+from umlshapes.types.UmlPosition import UmlPosition
+
+from umlio.BaseUmlToXml import BaseUmlToXml
+
+from umlio.IOTypes import ElementAttributes
+from umlio.IOTypes import UmlLinks
+from umlio.PyutToXml import PyutToXml
+
+from umlio.XMLConstants import XmlConstants
+
+
+class UmlLinksToXml(BaseUmlToXml):
+    def __init__(self):
+        super().__init__()
+        self.logger: Logger = getLogger(__name__)
+
+        self._pyutToXml: PyutToXml = PyutToXml()
+
+    def serialize(self, documentTop: Element, umlLinks: UmlLinks) -> Element:
+
+        for umlLink in umlLinks:
+            #     if isinstance(oglLink, OglInterface2):
+            #         self._oglInterface2ToXml(documentElement=documentTop, oglInterface=oglLink)
+            #     else:
+            self._oglLinkToXml(documentElement=documentTop, umlLink=umlLink)
+
+        return documentTop
+
+    def _oglLinkToXml(self, documentElement: Element, umlLink: UmlLink) -> Element:
+
+        attributes:        ElementAttributes = self._umlLinkAttributes(umlLink=umlLink)
+        oglLinkSubElement: Element           = SubElement(documentElement, XmlConstants.ELEMENT_UML_LINK, attrib=attributes)
+
+        if isinstance(umlLink, UmlAssociation):
+
+            associationName: UmlAssociationLabel = umlLink.associationName
+            src:             UmlAssociationLabel = umlLink.sourceCardinality
+            dst:             UmlAssociationLabel = umlLink.destinationCardinality
+            associationLabels = {
+                XmlConstants.ELEMENT_ASSOCIATION_LABEL:      associationName,
+                XmlConstants.ELEMENT_ASSOCIATION_SOURCE_LABEL:      src,
+                XmlConstants.ELEMENT_ASSOCIATION_DESTINATION_LABEL: dst
+            }
+            for eltName in associationLabels:
+                umlAssociationLabel: UmlAssociationLabel = associationLabels[eltName]
+
+                linkDelta: DeltaXY = umlAssociationLabel.linkDelta
+
+                labelAttributes: ElementAttributes = ElementAttributes({
+                    XmlConstants.ATTRIBUTE_DELTA_X: str(linkDelta.deltaX),
+                    XmlConstants.ATTRIBUTE_DELTA_Y: str(linkDelta.deltaY),
+                })
+                # noinspection PyUnusedLocal
+                labelElement: Element = SubElement(oglLinkSubElement, eltName, attrib=labelAttributes)
+
+        lineControlPoints: LineControlPoints = umlLink.GetLineControlPoints()
+        realControlPoints: LineControlPoints = self._removeEndPoints(umlLink=umlLink, lineControlPoints=lineControlPoints)
+        for pt in realControlPoints:
+            wxPoint: Point = cast(Point, pt)
+            controlPointAttributes: ElementAttributes = ElementAttributes({
+                XmlConstants.ATTRIBUTE_X: str(wxPoint.x),
+                XmlConstants.ATTRIBUTE_Y: str(wxPoint.y),
+            })
+            SubElement(oglLinkSubElement, XmlConstants.ELEMENT_MODEL_LINE_CONTROL_POINT, attrib=controlPointAttributes)
+
+        self._pyutToXml.pyutLinkToXml(pyutLink=umlLink.pyutLink, oglLinkElement=oglLinkSubElement)
+
+        return oglLinkSubElement
+
+    # def _oglInterface2ToXml(self, documentElement: Element, oglInterface: OglInterface2) -> Element:
+    #     """
+    #
+    #     Args:
+    #         documentElement:  untangler element for document
+    #         oglInterface:     Lollipop to serialize
+    #     Returns:
+    #         New untangle element
+    #     """
+    #     destAnchor:      SelectAnchorPoint = oglInterface.destinationAnchor
+    #     attachmentPoint: AttachmentSide    = destAnchor.attachmentPoint
+    #     x, y = destAnchor.GetPosition()
+    #
+    #     attributes: ElementAttributes = ElementAttributes({
+    #         XmlConstants.ATTR_LOLLIPOP_ATTACHMENT_POINT: attachmentPoint.__str__(),
+    #         XmlConstants.ATTR_X:                         str(x),
+    #         XmlConstants.ATTR_Y:                         str(y),
+    #     })
+    #     oglInterface2: Element = SubElement(documentElement, XmlConstants.ELEMENT_OGL_INTERFACE2, attrib=attributes)
+    #
+    #     self._pyutToXml.pyutInterfaceToXml(oglInterface.pyutInterface, oglInterface2)
+    #     return oglInterface2
+    #
+    def _umlLinkAttributes(self, umlLink: UmlLink) -> ElementAttributes:
+
+        # srcX, srcY   = umlLink.sourceAnchor.model.GetPosition()
+        # destX, destY = umlLink.destinationAnchor.model.GetPosition()
+
+        umlLinkId:    str         = str(umlLink.id)
+        endPoints:    EndPoints   = umlLink.endPoints
+        fromPosition: UmlPosition = endPoints.fromPosition
+        toPosition:   UmlPosition = endPoints.toPosition
+
+        attributes: ElementAttributes = ElementAttributes({
+            XmlConstants.ATTRIBUTE_ID:          umlLinkId,
+            XmlConstants.ATTRIBUTE_LINK_FROM_X: str(fromPosition.x),
+            XmlConstants.ATTRIBUTE_LINK_FROM_Y: str(fromPosition.y),
+            XmlConstants.ATTRIBUTE_LINK_TO_X:   str(toPosition.x),
+            XmlConstants.ATTRIBUTE_LINK_TO_Y:   str(toPosition.y),
+            XmlConstants.ATTRIBUTE_SPLINE:      str(umlLink.spline)   # piecewise polynomial function
+        })
+
+        return attributes
+
+    def _removeEndPoints(self, umlLink: 'UmlLink', lineControlPoints: LineControlPoints) -> LineControlPoints:
+        """
+        Do not consider the end points
+
+        Args:
+            umlLink:
+            lineControlPoints:
+
+        Returns:  The control points less the 2 end points
+        """
+
+        realControlPoints: LineControlPoints = LineControlPoints(lineControlPoints[:])
+
+        x1, y1, x2, y2 = umlLink.FindLineEndPoints()
+
+        pt1: Point = Point(x1, y1)
+        pt2: Point = Point(x2, y2)
+
+        realControlPoints.remove(pt1)
+        realControlPoints.remove(pt2)
+
+        return realControlPoints