cyberiadaml-py 0.1.0__tar.gz

cyberiadaml_py-0.1.0/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

cyberiadaml_py-0.1.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.1
+Name: cyberiadaml-py
+Version: 0.1.0
+Summary: The Python 3 library for processing the CyberiadaML state machine graphs
+Author: L140-beep
+Author-email: kartoshka0302@mail.ru
+Requires-Python: >=3.10,<3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Requires-Dist: pydantic (>=2.6.1,<3.0.0)
+Requires-Dist: xmltodict (>=0.13.0,<0.14.0)
+Description-Content-Type: text/markdown
+
+# The Cyberiada State Machine Python 3 Library
+
+The native Python 3 library for processing CyberiadaML - the version of GraphML for storing state machine graphs
+used by the Cyberiada Project. 
+
+The code is distributed under the Lesser GNU Public License (version 3), the documentation -- under
+the GNU Free Documentation License (version 1.3).
+
+## Requirements
+
+* `poetry` (which installs latter libraries)
+* `xmltodict`
+* `pydantic`
+* `types-xmltodict`
+

cyberiadaml_py-0.1.0/README.md

@@ -0,0 +1,14 @@
+# The Cyberiada State Machine Python 3 Library
+
+The native Python 3 library for processing CyberiadaML - the version of GraphML for storing state machine graphs
+used by the Cyberiada Project. 
+
+The code is distributed under the Lesser GNU Public License (version 3), the documentation -- under
+the GNU Free Documentation License (version 1.3).
+
+## Requirements
+
+* `poetry` (which installs latter libraries)
+* `xmltodict`
+* `pydantic`
+* `types-xmltodict`

cyberiadaml_py-0.1.0/cyberiadaml_py/__init__.py

@@ -0,0 +1 @@
+"""Library for parsing and building CyberiadaMl schemes."""

cyberiadaml_py-0.1.0/cyberiadaml_py/cyberiadaml_builder.py

@@ -0,0 +1,261 @@
+"""Module implements building CyberiadaML schemes."""
+from typing import Dict, Iterable, List
+
+from xmltodict import unparse
+from pydantic import RootModel
+
+try:
+    from cyberiadaml_py.types.cgml_scheme import (
+        CGML,
+        CGMLDataNode,
+        CGMLEdge,
+        CGMLGraph,
+        CGMLGraphml,
+        CGMLKeyNode,
+        CGMLNode
+    )
+    from cyberiadaml_py.types.common import Point, Rectangle
+    from cyberiadaml_py.types.elements import (
+        AwailableKeys,
+        CGMLComponent,
+        CGMLElements,
+        CGMLInitialState,
+        CGMLNote,
+        CGMLState,
+        CGMLTransition
+    )
+except ImportError:
+    from .types.cgml_scheme import (
+        CGML,
+        CGMLDataNode,
+        CGMLEdge,
+        CGMLGraph,
+        CGMLGraphml,
+        CGMLKeyNode,
+        CGMLNode
+    )
+    from .types.common import Point, Rectangle
+    from .types.elements import (
+        AwailableKeys,
+        CGMLComponent,
+        CGMLElements,
+        CGMLInitialState,
+        CGMLNote,
+        CGMLState,
+        CGMLTransition
+    )
+
+
+class CGMLBuilderException(Exception):
+    """Logical errors during building CGML scheme."""
+
+    ...
+
+
+class CGMLBuilder:
+    """Contains functions to build CGML scheme."""
+
+    def __init__(self) -> None:
+        self.scheme: CGML = CGMLBuilder.createEmptyscheme()
+
+    @staticmethod
+    def createEmptyscheme() -> CGML:
+        """Create empty CyberiadaML scheme."""
+        return CGML(graphml=CGMLGraphml(
+            [],
+            'http://graphml.graphdrawing.org/xmlns',
+        ))
+
+    def build(self, elements: CGMLElements) -> str:
+        """Build CGML scheme from elements."""
+        self.scheme.graphml.key = self._getKeys(elements.keys)
+        self.scheme.graphml.data = self._getFormatNode(elements.format)
+        self.scheme.graphml.graph = CGMLGraph(
+            'directed',
+            'G',
+        )
+        nodes: List[CGMLNode] = [*self._getStateNodes(elements.states),
+                                 *self._getNoteNodes(
+                                     list(elements.notes.values())),
+                                 self._getMetaNode(
+                                     elements.meta, elements.platform),
+                                 *self._getComponentsNodes(elements.components)
+                                 ]
+        edges: List[CGMLEdge] = [
+            *self._getEdges(elements.transitions),
+            *self._getComponentsEdges(elements.components)
+        ]
+        if elements.initial_state is not None:
+            nodes.append(
+                self._getInitialNode(elements.initial_state))
+            edges.append(self._getInitialEdge(
+                elements.initial_state.transitionId,
+                elements.initial_state.id,
+                elements.initial_state.target))
+        self.scheme.graphml.graph.node = nodes
+        self.scheme.graphml.graph.edge = edges
+        scheme: CGML = RootModel[CGML](self.scheme).model_dump(
+            by_alias=True, exclude_defaults=True)
+        # У model_dump неправильный возвращаемый тип (CGML),
+        # поэтому приходится явно показывать линтеру, что это dict
+        if isinstance(scheme, dict):
+            return unparse(scheme, pretty=True)
+        else:
+            raise CGMLBuilderException('Internal error: scheme is not dict')
+
+    def _getComponentsEdges(self,
+                            components: List[CGMLComponent]) -> List[CGMLEdge]:
+        edges: List[CGMLEdge] = []
+        for component in components:
+            edges.append(CGMLEdge(f'edge_{component.id}', '', component.id))
+        return edges
+
+    def _getComponentsNodes(self,
+                            components: List[CGMLComponent]) -> List[CGMLNode]:
+        nodes: List[CGMLNode] = []
+        for component in components:
+            node: CGMLNode = CGMLNode(component.id)
+            data: List[CGMLDataNode] = []
+            data.append(self._nameToData(component.id))
+            data.append(self._actionsToData(component.parameters))
+            node.data = data
+            nodes.append(node)
+        return nodes
+
+    def _getInitialEdge(self, transitionId: str,
+                        initId: str, target: str) -> CGMLEdge:
+        return CGMLEdge(
+            transitionId,
+            initId,
+            target
+        )
+
+    def _getEdges(self,
+                  transitions: Dict[str, CGMLTransition]) -> List[CGMLEdge]:
+        edges: List[CGMLEdge] = []
+        for transition in list(transitions.values()):
+            edge: CGMLEdge = CGMLEdge(
+                transition.id, transition.source, transition.target)
+            data: List[CGMLDataNode] = []
+            data.append(self._actionsToData(transition.actions))
+            if transition.color is not None:
+                data.append(self._colorToData(transition.color))
+            if transition.position is not None:
+                data.append(self._pointToData(transition.position))
+            data.extend(transition.unknownDatanodes)
+            edge.data = data
+            edges.append(edge)
+        return edges
+
+    def _getInitialNode(self, initialState: CGMLInitialState) -> CGMLNode:
+        initialNode: CGMLNode = CGMLNode(initialState.id)
+        data: List[CGMLDataNode] = []
+        if initialState.position is not None:
+            data.append(self._pointToData(initialState.position))
+        data.append(self._getInitialDataNode())
+        initialNode.data = data
+        return initialNode
+
+    def _getInitialDataNode(self) -> CGMLDataNode:
+        return CGMLDataNode(
+            'dInitial'
+        )
+
+    def _getMetaNode(self, meta: str, platform: str) -> CGMLNode:
+        metaNode: CGMLNode = CGMLNode('')
+        data: List[CGMLDataNode] = []
+        data.append(self._nameToData(platform))
+        data.append(self._actionsToData(meta))
+        metaNode.data = data
+        return metaNode
+
+    def _getNoteNodes(self, notes: List[CGMLNote]) -> List[CGMLNode]:
+        nodes: List[CGMLNode] = []
+        for note in notes:
+            data: List[CGMLDataNode] = []
+            data.append(self._noteToData(note.text))
+            data.append(self._pointToData(note.position))
+            data.extend(note.unknownDatanodes)
+            nodes.append(CGMLNode(
+                note.id,
+                data=data
+            ))
+        return nodes
+
+    def _pointToData(self, point: Point) -> CGMLDataNode:
+        return CGMLDataNode(
+            'dGeometry', None, str(point.x), str(point.y)
+        )
+
+    def _noteToData(self, note_information: str) -> CGMLDataNode:
+        return CGMLDataNode('dNote', note_information)
+
+    def _getStateNodes(self, states: Dict[str, CGMLState]) -> List[CGMLNode]:
+        def _getCGMLNode(nodes: Dict[str, CGMLNode],
+                         state: CGMLState, stateId: str) -> CGMLNode:
+            if nodes.get(stateId) is not None:
+                return nodes[stateId]
+            else:
+                node = CGMLNode(stateId)
+                data: List[CGMLDataNode] = []
+                if state.bounds is not None:
+                    data.append(self._boundsToData(state.bounds))
+                if state.color is not None:
+                    data.append(self._colorToData(state.color))
+                data.append(self._actionsToData(state.actions))
+                data.append(self._nameToData(state.name))
+                data.extend(state.unknownDatanodes)
+                node.data = data
+                return node
+
+        nodes: Dict[str, CGMLNode] = {}
+        for stateId in list(states.keys()):
+            state: CGMLState = states[stateId]
+            node: CGMLNode = _getCGMLNode(nodes, state, stateId)
+            if state.parent is not None:
+                parentState: CGMLState = states[state.parent]
+                parent: CGMLNode = _getCGMLNode(
+                    nodes, parentState, state.parent)
+                if parent.graph is None:
+                    parent.graph = CGMLGraph(
+                        node=[node]
+                    )
+                elif isinstance(parent.graph, CGMLGraph):
+                    if (parent.graph.node is not None and
+                            isinstance(parent.graph.node, Iterable)):
+                        parent.graph.node.append(node)
+                    else:
+                        parent.graph.node = [node]
+                nodes[state.parent] = parent
+            else:
+                nodes[stateId] = node
+        return list(nodes.values())
+
+    def _nameToData(self, name: str) -> CGMLDataNode:
+        return CGMLDataNode('dName', name)
+
+    def _colorToData(self, color: str) -> CGMLDataNode:
+        return CGMLDataNode('dColor', color)
+
+    def _actionsToData(self, actions: str) -> CGMLDataNode:
+        return CGMLDataNode(
+            'dData', actions
+        )
+
+    def _boundsToData(self, bounds: Rectangle) -> CGMLDataNode:
+        return CGMLDataNode('dGeometry',
+                            None,
+                            str(bounds.x),
+                            str(bounds.y),
+                            str(bounds.width),
+                            str(bounds.height))
+
+    def _getFormatNode(self, format: str) -> CGMLDataNode:
+        return CGMLDataNode('gFormat', format)
+
+    def _getKeys(self, awaialaibleKeys: AwailableKeys) -> List[CGMLKeyNode]:
+        keyNodes: List[CGMLKeyNode] = []
+        for key in list(awaialaibleKeys.keys()):
+            keyNodes.extend(awaialaibleKeys[key])
+
+        return keyNodes

cyberiadaml_py-0.1.0/cyberiadaml_py/cyberiadaml_parser.py

@@ -0,0 +1,373 @@
+"""The module implements parsing CyberiadaML schemes."""
+from collections import defaultdict
+from collections.abc import Iterable
+from typing import Any, Dict, List, Optional
+
+from xmltodict import parse
+
+try:
+    from .types.common import Point, Rectangle
+    from .types.cgml_scheme import (
+        CGML,
+        CGMLDataNode,
+        CGMLEdge,
+        CGMLGraph,
+        CGMLNode
+    )
+    from .types.elements import (
+        CGMLComponent,
+        CGMLElements,
+        AwailableKeys,
+        CGMLInitialState,
+        CGMLNote,
+        CGMLState,
+        CGMLTransition
+    )
+except ImportError:
+    from cyberiadaml_py.types.cgml_scheme import (
+        CGML,
+        CGMLDataNode,
+        CGMLEdge,
+        CGMLGraph,
+        CGMLNode
+    )
+    from cyberiadaml_py.types.common import Point, Rectangle
+    from cyberiadaml_py.types.elements import (
+        CGMLComponent,
+        CGMLElements,
+        AwailableKeys,
+        CGMLInitialState,
+        CGMLNote,
+        CGMLState,
+        CGMLTransition
+    )
+
+
+class CGMLParserException(Exception):
+    """Logical errors during parsing CGML scheme."""
+
+    ...
+
+
+class CGMLParser:
+    """Class that contains functions for parsing CyberiadaML."""
+
+    def __init__(self) -> None:
+        self.elements: CGMLElements = CGMLParser.createEmptyElements()
+
+    @staticmethod
+    def createEmptyElements() -> CGMLElements:
+        """Create CGMLElements with empty fields."""
+        return CGMLElements(
+            states={},
+            transitions={},
+            components=[],
+            platform='',
+            format='',
+            meta='',
+            keys=defaultdict(),
+            notes={}
+        )
+
+    def parseCGML(self, graphml: str) -> CGMLElements:
+        """
+        Parse CyberiadaGraphml scheme.
+
+        Args:
+            graphml (str): CyberiadaML scheme.
+
+        Returns:
+            CGMLElements: notes, states, transitions,\
+                initial state and components
+        Raises:
+            CGMLParserException('Data node with key "gFormat" is empty'):\
+                content of <data key='gFormat'> is None
+            CGMLParserException('Data node with key "gFormat" is missing'):\
+                <data key='gFormat'> doesn't exist in graphml->data.s
+            CGMLParserException('No position for note!):\
+                <node>, that contains <data key='dNote'>, graphml
+                    doesn't contains <data key='dGeometry' x='...' y='...'>
+            CGMLParserException('Unknown key "key" for "node-type",\
+                                    did you forgot ...'):\
+                                        using an undeclarated key
+            CGMLParserException('<node-type> with key\
+                dGeometry doesnt have x, y properties'): \
+                    <data key='dGeometry'> must contain at least x and y\
+                        properties (width and height are additional)
+            ValidationError(...): pydatinc's validation error, occurs when\
+                the scheme doesn't match the format.
+        """
+        self.elements = CGMLParser.createEmptyElements()
+        cgml = CGML(**parse(graphml))
+        self.elements.format = self._getFormat(cgml)
+        if self.elements.format != 'Cyberiada-GraphML':
+            raise CGMLParserException(
+                ('Format must be '
+                 f'Cyberiada-GraphML, but got {self.elements.format}'))
+        self.elements.keys = self._getAwaialbleKeys(cgml)
+        graphs: List[CGMLGraph] = self._toList(cgml.graphml.graph)
+        states: Dict[str, CGMLState] = {}
+        transitions: Dict[str, CGMLTransition] = {}
+        notes: Dict[str, CGMLNote] = {}
+        for graph in graphs:
+            states = states | self._parseGraphNodes(graph)
+            transitions = transitions | self._parseGraphEdges(graph)
+        try:
+            self.elements.platform, self.elements.meta = self._getMeta(
+                states[''])
+            del states['']
+        except KeyError:
+            raise CGMLParserException('Meta node is missing')
+        for stateId in list(states.keys()):
+            state, isInit = self._processStateData(states[stateId], stateId)
+            if isinstance(state, CGMLNote):
+                notes[state.id] = state
+                del states[stateId]
+            elif isinstance(state, CGMLState):
+                if isInit:
+                    if self.elements.initial_state is not None:
+                        raise CGMLParserException('Double init states')
+                    position: Point | None = None
+                    if state.bounds is not None:
+                        position = Point(state.bounds.x, state.bounds.y)
+                    self.elements.initial_state = CGMLInitialState(
+                        transitionId='', id=stateId,
+                        target='', position=position)
+                    del states[stateId]
+                else:
+                    states[stateId] = state
+            else:
+                raise CGMLParserException(
+                    'Internal error: Unknown type of node')
+        # TODO Вынести в отдельные функции
+        componentIds: List[str] = []
+        for transition in list(transitions.values()):
+            processedTransition: CGMLTransition = self._processEdgeData(
+                transition)
+            if (self.elements.initial_state is not None and
+                    (processedTransition.source ==
+                        self.elements.initial_state.id)):
+                self.elements.initial_state.target = processedTransition.target
+                self.elements.initial_state\
+                    .transitionId = processedTransition.id
+            elif transition.source == '':
+                componentIds.append(transition.target)
+            else:
+                self.elements.transitions[transition.id] = processedTransition
+        for componentId in componentIds:
+            componentState: CGMLState | None = states.get(componentId)
+            if componentState is None:
+                raise CGMLParserException('Unknown component node')
+            self.elements.components.append(CGMLComponent(
+                id=componentId,
+                parameters=componentState.actions
+            ))  # TODO: raise exception if smth else
+            del states[componentId]
+        self.elements.states = states
+        self.elements.notes = notes
+        return self.elements
+
+    def _getDataContent(self, dataNode: CGMLDataNode) -> str:
+        return dataNode.content if dataNode.content is not None else ''
+
+    def _processEdgeData(self, transition: CGMLTransition) -> CGMLTransition:
+        newTransition = CGMLTransition(
+            id=transition.id,
+            source=transition.source,
+            target=transition.target,
+            actions=transition.actions,
+            unknownDatanodes=[]
+        )
+        for dataNode in transition.unknownDatanodes:
+            for keyNode in self.elements.keys['edge']:
+                if dataNode.key == keyNode.id:
+                    break
+            else:
+                raise CGMLParserException(
+                    (f'Unknown key {dataNode.key} for edge, did you forgot: '
+                     f'"<key id="{dataNode.key}" for="edge"/>"?'))
+            match dataNode.key:
+                case 'dData':
+                    newTransition.actions = self._getDataContent(dataNode)
+                case 'dGeometry':
+                    if dataNode.x is None or dataNode.y is None:
+                        raise CGMLParserException(
+                            'Edge with key dGeometry\
+                                doesnt have x, y properties')
+                    newTransition.position = Point(
+                        float(dataNode.x), float(dataNode.y))
+                case 'dColor':
+                    newTransition.color = self._getDataContent(dataNode)
+                case _:
+                    newTransition.unknownDatanodes.append(dataNode)
+        return newTransition
+
+    def _processStateData(self,
+                          state: CGMLState,
+                          stateId: str) -> tuple[CGMLState | CGMLNote, bool]:
+        """Return tuple[CGMLState | CGMLNote, isInit]."""
+        # no mutations? B^)
+        newState = CGMLState(
+            name=state.name,
+            actions=state.actions,
+            unknownDatanodes=[],
+            bounds=state.bounds,
+            parent=state.parent
+        )
+        isNote: bool = False
+        isInit: bool = False
+        for dataNode in state.unknownDatanodes:
+            match dataNode.key:
+                case 'dName':
+                    newState.name = self._getDataContent(dataNode)
+                case 'dGeometry':
+                    if dataNode.x is None or dataNode.y is None:
+                        raise CGMLParserException(
+                            'Node with key dGeometry\
+                                doesnt have x, y properties')
+                    x: float = float(dataNode.x)
+                    y: float = float(dataNode.y)
+
+                    if (dataNode.width is not None and
+                            dataNode.height is not None):
+                        newState.bounds = Rectangle(
+                            x=x,
+                            y=y,
+                            width=float(dataNode.width),
+                            height=float(dataNode.height)
+                        )
+                    else:
+                        newState.bounds = Rectangle(
+                            x=x,
+                            y=y
+                        )
+                case 'dData':
+                    newState.actions = self._getDataContent(dataNode)
+                case 'dNote':
+                    isNote = True
+                    newState.actions = self._getDataContent(dataNode)
+                case 'dInitial':
+                    isInit = True
+                    if isNote:
+                        raise CGMLParserException('dInit in dNote')
+                case 'dColor':
+                    newState.color = self._getDataContent(dataNode)
+                case _:
+                    newState.unknownDatanodes.append(dataNode)
+        if isNote:
+            bounds: Rectangle | None = newState.bounds
+            if bounds is None:
+                raise CGMLParserException('No position for note!')
+            else:
+                return (CGMLNote(
+                    id=stateId,
+                    position=Point(
+                        x=bounds.x,
+                        y=bounds.y,
+                    ),
+                    text=newState.actions,
+                    unknownDatanodes=newState.unknownDatanodes
+                ), False)
+        return (newState, isInit)
+
+    def _getMeta(self, metaNode: CGMLState) -> tuple[str, str]:
+        """Return tuple[platfrom, meta]."""
+        dataNodes: List[CGMLDataNode] = self._toList(metaNode.unknownDatanodes)
+        platform: str = ''
+        meta: str = ''
+        for dataNode in dataNodes:
+            match dataNode.key:
+                case 'dName':
+                    platform = self._getDataContent(dataNode)
+                case 'dData':
+                    meta = self._getDataContent(dataNode)
+        return platform, meta
+
+    def _toList(self, nodes: List | None | Any) -> List:
+        if nodes is None:
+            return []
+        if isinstance(nodes, list):
+            return nodes
+        else:
+            return [nodes]
+
+    def _parseGraphEdges(self, root: CGMLGraph) -> Dict[str, CGMLTransition]:
+        def _parseEdge(edge: CGMLEdge,
+                       cgmlTransitions: Dict[str, CGMLTransition]) -> None:
+            cgmlTransitions[edge.id] = CGMLTransition(
+                id=edge.id,
+                source=edge.source,
+                target=edge.target,
+                actions='',
+                unknownDatanodes=self._toList(
+                        edge.data),
+            )
+
+        cgmlTransitions: Dict[str, CGMLTransition] = {}
+        if root.edge is not None:
+            if isinstance(root.edge, Iterable):
+                for edge in root.edge:
+                    _parseEdge(edge, cgmlTransitions)
+            else:
+                _parseEdge(root.edge, cgmlTransitions)
+        return cgmlTransitions
+
+    def _parseGraphNodes(self,
+                         root: CGMLGraph,
+                         parent: Optional[str] = None) -> Dict[str, CGMLState]:
+        def parseNode(node: CGMLNode) -> Dict[str, CGMLState]:
+            cgmlStates: Dict[str, CGMLState] = {}
+            cgmlStates[node.id] = CGMLState(
+                name='',
+                actions='',
+                unknownDatanodes=self._toList(node.data),
+            )
+            if parent is not None:
+                cgmlStates[node.id].parent = parent
+            graphs: List[CGMLGraph] = self._toList(node.graph)
+            for graph in graphs:
+                cgmlStates = cgmlStates | self._parseGraphNodes(
+                    graph, node.id)
+
+            return cgmlStates
+
+        cgmlStates: Dict[str, CGMLState] = {}
+        if root.node is not None:
+            if isinstance(root.node, Iterable):
+                for node in root.node:
+                    cgmlStates = cgmlStates | parseNode(node)
+            else:
+                cgmlStates = cgmlStates | parseNode(root.node)
+        return cgmlStates
+
+    def _checkDataNodeKey(self, node_name: str, key: str,
+                          awaialableKeys: AwailableKeys) -> bool:
+        return key in awaialableKeys[node_name]
+
+    # key nodes to comfortable dict
+    def _getAwaialbleKeys(self, cgml: CGML) -> AwailableKeys:
+        keyNodeDict: AwailableKeys = defaultdict(lambda: [])
+        if cgml.graphml.key is not None:
+            if isinstance(cgml.graphml.key, Iterable):
+                for keyNode in cgml.graphml.key:
+                    keyNodeDict[keyNode.for_].append(keyNode)
+            else:
+                keyNodeDict[cgml.graphml.key.for_].append(cgml.graphml.key)
+        return keyNodeDict
+
+    def _getFormat(self, cgml: CGML) -> str:
+        # TODO: DRY
+        if isinstance(cgml.graphml.data, Iterable):
+            for dataNode in cgml.graphml.data:
+                if dataNode.key == 'gFormat':
+                    if dataNode.content is not None:
+                        return dataNode.content
+                    raise CGMLParserException(
+                        'Data node with key "gFormat" is empty')
+        else:
+            if cgml.graphml.data.key == 'gFormat':
+                if cgml.graphml.data.content is not None:
+                    return cgml.graphml.data.content
+                raise CGMLParserException(
+                    'Data node with key "gFormat" is empty')
+        raise CGMLParserException('Data node with key "gFormat" is missing')

cyberiadaml_py-0.1.0/cyberiadaml_py/types/cgml_scheme.py

@@ -0,0 +1,74 @@
+"""Module contains types, that representing unprocessed CyberiadaML scheme."""
+
+from typing import List, Optional
+
+from pydantic.dataclasses import dataclass
+from pydantic import Field, ConfigDict
+
+
+@dataclass(config=ConfigDict(extra='forbid'))
+class CGMLDataNode:
+    """Type representing <data> node."""
+
+    key: str = Field(alias='@key')
+    content: Optional[str] = Field(default=None, alias='#text')
+    x: Optional[str] = Field(default=None, alias='@x')
+    y: Optional[str] = Field(default=None, alias='@y')
+    width: Optional[str] = Field(default=None, alias='@width')
+    height: Optional[str] = Field(default=None, alias='@height')
+
+
+@dataclass(config=ConfigDict(extra='allow'))
+class CGMLKeyNode:
+    """Type representing <key> node."""
+
+    id: str = Field(alias='@id')
+    for_: str = Field(alias='@for')
+    attr_name: Optional[str] = Field(default=None, alias='@attr.name')
+    attr_type: Optional[str] = Field(default=None, alias='@attr.type')
+
+
+@dataclass(config=ConfigDict(extra='forbid'))
+class CGMLEdge:
+    """Type representing <edge> node."""
+
+    id: str = Field(alias='@id')
+    source: str = Field(alias='@source')
+    target: str = Field(alias='@target')
+    data: Optional[List[CGMLDataNode] | CGMLDataNode] = None
+
+
+@dataclass(config=ConfigDict(extra='forbid'))
+class CGMLGraph:
+    """Type representing <graph> node."""
+
+    edgedefault: Optional[str] = Field(alias='@edgedefault', default=None)
+    id: Optional[str] = Field(alias='@id', default=None)
+    node: Optional[List['CGMLNode'] | 'CGMLNode'] = None
+    edge: Optional[List[CGMLEdge] | CGMLEdge] = None
+
+
+@dataclass(config=ConfigDict(extra='forbid'))
+class CGMLNode:
+    """Type representing <node> node."""
+
+    id: str = Field(alias='@id')
+    graph: Optional[CGMLGraph | List[CGMLGraph]] = None
+    data: List[CGMLDataNode] | CGMLDataNode | None = None
+
+
+@dataclass(config=ConfigDict(extra='forbid'))
+class CGMLGraphml:
+    """Type representing <graphml> node."""
+
+    data: CGMLDataNode | List[CGMLDataNode]
+    xmlns: str = Field(alias='@xmlns')
+    key: Optional[List[CGMLKeyNode] | CGMLKeyNode] = None
+    graph: Optional[List[CGMLGraph] | CGMLGraph] = None
+
+
+@dataclass(config=ConfigDict(extra='forbid'))
+class CGML:
+    """Root type of CyberiadaML scheme."""
+
+    graphml: CGMLGraphml

cyberiadaml_py-0.1.0/cyberiadaml_py/types/common.py

@@ -0,0 +1,24 @@
+"""Module contains common geometry classes."""
+from dataclasses import dataclass
+from typing import Optional, TypeAlias
+
+
+@dataclass
+class Point:
+    """Point data class."""
+
+    x: float
+    y: float
+
+
+@dataclass
+class Rectangle:
+    """Rectangle data class."""
+
+    x: float
+    y: float
+    width: Optional[float] = None
+    height: Optional[float] = None
+
+
+Key: TypeAlias = str

cyberiadaml_py-0.1.0/cyberiadaml_py/types/elements.py

@@ -0,0 +1,152 @@
+"""Module contains the types of parsed scheme's elements."""
+from typing import (
+    List,
+    Dict,
+    DefaultDict,
+    Optional,
+    TypeAlias
+)
+
+from pydantic.dataclasses import dataclass
+from pydantic import Field
+
+try:
+    from .cgml_scheme import CGMLDataNode, CGMLKeyNode
+    from .common import Point, Rectangle
+except ImportError:
+    from cyberiadaml_py.types.cgml_scheme import CGMLDataNode, CGMLKeyNode
+    from cyberiadaml_py.types.common import Point, Rectangle
+#  { node: ['dGeometry', ...], edge: ['dData', ...]}
+AwailableKeys: TypeAlias = DefaultDict[str, List[CGMLKeyNode]]
+
+
+@dataclass
+class CGMLState:
+    """
+    Data class with information about state.
+
+    State is <node>, that not connected with meta node,\
+        doesn't have data node with key 'dNote' or 'dInitial'
+
+    Parameters:
+    name: content of data node with key 'dName'.
+    actions: content of data node with key 'dData'.
+    bounds: x, y, width, height properties of data node with key 'dGeometry'.
+    parent: parent state id.
+    color: content of data node with key 'dColor'.
+    unknownDatanodes: all datanodes, whose information\
+        is not included in the type.
+    """
+
+    name: str
+    actions: str
+    unknownDatanodes: List[CGMLDataNode]
+    parent: Optional[str] = None
+    bounds: Optional[Rectangle] = None
+    color: Optional[str] = None
+
+
+@dataclass
+class CGMLComponent:
+    """
+    Data class with information about component.
+
+    Component is node, that connected with meta node (<node id=''>).
+    parameters: content of data node with key 'dData'.
+    """
+
+    id: str
+    parameters: str
+
+
+@dataclass
+class CGMLInitialState:
+    """
+    Data class with information about initial state (pseudo node).
+
+    Intiial state is <node>, that contains data node with key 'dInitial'.
+
+    Parameters:
+    id: state's id.
+    target: state's id, thats connetcted with initial state\
+        (<edge source="initial state id" target="target state's id">)
+    position: x, y properties of data node with 'dGeometry' key.
+    """
+
+    transitionId: str
+    id: str
+    target: str
+    position: Optional[Point] = None
+
+
+@dataclass
+class CGMLTransition:
+    """
+    Data class with information about transition(<edge>).
+
+    Parameters:
+    source: <edge> source property's content.
+    target: <edge> target property's content.
+    actions: content of data node with 'dData' key.
+    color: content of data node with 'dColor' key.
+    position: x, y properties of data node with 'dGeometry' key.
+    unknownDatanodes: all datanodes, whose information\
+        is not included in the type.
+    """
+
+    id: str
+    source: str
+    target: str
+    actions: str
+    unknownDatanodes: List[CGMLDataNode]
+    color: Optional[str] = None
+    position: Optional[Point] = None
+
+
+@dataclass
+class CGMLNote:
+    """
+    Dataclass with infromation about note.
+
+    Note is <node> containing data node with key 'dNote'
+    unknownDatanodes: all datanodes, whose information\
+        is not included in the type.
+    """
+
+    position: Point
+    text: str
+    unknownDatanodes: List[CGMLDataNode]
+    id: str = Field(serialization_alias='@id')
+
+
+@dataclass
+class CGMLElements:
+    """
+    Dataclass with elements of parsed scheme.
+
+    Contains dict of CGMLStates, where the key is state's id.
+    Also contains trainstions, components, awaialable keys, notes.
+
+    States doesn't contains components nodes and initial state.
+    Transitions doesn't contains edges from meta-node(<node id=''>)\
+        to components nodes.
+
+    Parameters:
+    meta: content of data node\
+        with key 'dData' inside <node id="">
+    format: content of data node with key 'gFormat'.
+    platform: content of data node with key 'dName'\
+        inside <node id="">
+    keys: dict of KeyNodes, where the key is 'for' attribute.\
+        Example: { "node": [KeyNode, ...], "edge": [...] }
+    """
+
+    states: Dict[str, CGMLState]
+    transitions: Dict[str, CGMLTransition]
+    components: List[CGMLComponent]
+    platform: str
+    meta: str
+    format: str
+    keys: AwailableKeys
+    notes: Dict[str, CGMLNote]
+    initial_state: Optional[CGMLInitialState] = None

cyberiadaml_py-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[tool.poetry]
+name = "cyberiadaml-py"
+version = "0.1.0"
+description = "The Python 3 library for processing the CyberiadaML state machine graphs"
+authors = ["L140-beep <kartoshka0302@mail.ru>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "~3.10"
+xmltodict = "^0.13.0"
+pydantic = "^2.6.1"
+
+
+[tool.poetry.group.dev.dependencies]
+types-xmltodict = "^0.13.0.3"
+pytest = "^8.0.1"
+mypy = "^1.8.0"
+flake8 = "^7.0.0"
+flake8-docstrings = "^1.7.0"
+flake8-import-order = "^0.18.2"
+flake8-quotes = "^3.4.0"
+flake8-pyproject = "^1.2.3"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.flake8]
+import-order-style="pep8"
+inline-quotes = "single"
+ignore=["D107", "W504"]