Skip to content

serializers

This submodule provides a serializer that transforms data from an ELK- layouted diagram _elkjs.ELKOutputData according to _elkjs.ELKInputData. The pre-layouted data was collected with the functions from collectors.

ElkChildType module-attribute 🔗

ElkChildType = str

Elk types can be one of the following types: * graph * node * port * label * edge * junction.

DiagramSerializer 🔗

DiagramSerializer(elk_diagram: context.ContextDiagram)

Serialize an elk_diagram into an diagram.Diagram.

ATTRIBUTE DESCRIPTION
model

The MelodyModel instance.

diagram

The created diagram.Diagram instance.

TYPE: Diagram

Source code in capellambse_context_diagrams/serializers.py
59
60
61
62
63
64
def __init__(self, elk_diagram: context.ContextDiagram) -> None:
    self.model = elk_diagram.target._model
    self._diagram = elk_diagram
    self._cache: dict[str, cdiagram.DiagramElement] = {}
    self._edges: dict[str, EdgeContext] = {}
    self._junctions: dict[str, EdgeContext] = {}

deserialize_child 🔗

deserialize_child(child: _elkjs.ELKOutputChild, ref: cdiagram.Vector2D, parent: cdiagram.DiagramElement | None) -> None

Converts a child into aird elements and adds it to the diagram.

PARAMETER DESCRIPTION
child

The child to deserialize.

TYPE: ELKOutputChild

ref

The reference point of the child.

TYPE: Vector2D

parent

The parent of the child. This is either a box or an edge.

TYPE: DiagramElement | None

See Also

diagram.Box : Box class type. diagram.Edge : Edge class type. diagram.Circle : Circle class type. diagram.Diagram : Diagram class type that stores all previously named classes.

Source code in capellambse_context_diagrams/serializers.py
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
def deserialize_child(
    self,
    child: _elkjs.ELKOutputChild,
    ref: cdiagram.Vector2D,
    parent: cdiagram.DiagramElement | None,
) -> None:
    """Converts a `child` into aird elements and adds it to the
    diagram.

    Parameters
    ----------
    child
        The child to deserialize.
    ref
        The reference point of the child.
    parent
        The parent of the child. This is either a box or an edge.

    See Also
    --------
    [`diagram.Box`][capellambse.diagram.Box] : Box class type.
    [`diagram.Edge`][capellambse.diagram.Edge] : Edge class type.
    [`diagram.Circle`][capellambse.diagram.Circle] : Circle class
        type.
    [`diagram.Diagram`][capellambse.diagram.Diagram] : Diagram
        class type that stores all previously named classes.
    """
    uuid: str
    styleclass: str | None
    derived = False
    if child.id.startswith("__"):
        if ":" in child.id:
            styleclass, uuid = child.id[2:].split(":", 1)
        else:
            styleclass = uuid = child.id[2:]
        if styleclass.startswith("Derived-"):
            styleclass = styleclass.removeprefix("Derived-")
            derived = True
    else:
        styleclass = self.get_styleclass(child.id)
        uuid = child.id

    styleoverrides = self.get_styleoverrides(uuid, child, derived=derived)
    element: cdiagram.Box | cdiagram.Edge | cdiagram.Circle
    if child.type in {"node", "port"}:
        assert parent is None or isinstance(parent, cdiagram.Box)
        has_symbol_cls = makers.is_symbol(styleclass)
        is_port = child.type == "port"
        box_type = ("box", "symbol")[
            is_port
            or has_symbol_cls
            and not self._diagram.target.uuid == uuid
            and not self._diagram._display_symbols_as_boxes
        ]

        assert not isinstance(
            child, (_elkjs.ELKOutputEdge, _elkjs.ELKOutputJunction)
        )
        ref += (child.position.x, child.position.y)
        size = (child.size.width, child.size.height)
        features = []
        if styleclass in decorations.needs_feature_line:
            assert isinstance(child, _elkjs.ELKOutputNode)
            features = handle_features(child)

        element = cdiagram.Box(
            ref,
            size,
            uuid=uuid,
            parent=parent,
            port=is_port,
            styleclass=styleclass,
            styleoverrides=styleoverrides,
            features=features,
            context=getattr(child, "context", {}),
        )
        element.JSON_TYPE = box_type
        self.diagram.add_element(element)
        self._cache[uuid] = element
    elif child.type == "edge":
        styleclass = getattr(child, "styleClass", styleclass)
        styleclass = REMAP_STYLECLASS.get(styleclass, styleclass)
        EDGE_HANDLER.get(styleclass, lambda c: c)(child)

        source_id = child.sourceId
        if source_id.startswith("__"):
            source_id = source_id[2:].split(":", 1)[-1]

        target_id = child.targetId
        if target_id.startswith("__"):
            target_id = target_id[2:].split(":", 1)[-1]

        if child.routingPoints:
            refpoints = [
                ref + (point.x, point.y) for point in child.routingPoints
            ]
        else:
            source = self._cache[source_id]
            target = self._cache[target_id]
            assert isinstance(source, cdiagram.Box)
            assert isinstance(target, cdiagram.Box)
            refpoints = route_shortest_connection(source, target)

        element = cdiagram.Edge(
            refpoints,
            uuid=child.id,
            source=self.diagram[source_id],
            target=self.diagram[target_id],
            styleclass=styleclass,
            styleoverrides=styleoverrides,
            context=getattr(child, "context", {}),
        )
        self.diagram.add_element(element)
        self._cache[uuid] = element
    elif child.type == "label":
        assert parent is not None
        if parent.JSON_TYPE != "symbol":
            parent.styleoverrides.update(styleoverrides)

        if isinstance(parent, cdiagram.Box):
            attr_name = "floating_labels"
        else:
            attr_name = "labels"

        if (
            parent.port
            and self._diagram._port_label_position
            == _elkjs.PORT_LABEL_POSITION.OUTSIDE.name
        ):
            bring_labels_closer_to_port(child)

        if labels := getattr(parent, attr_name):
            label_box = labels[-1]
            label_box.label += " " + child.text
            label_box.size = cdiagram.Vector2D(
                max(label_box.size.x, child.size.width),
                label_box.size.y + child.size.height,
            )
            label_box.pos = cdiagram.Vector2D(
                min(label_box.pos.x, ref.x + child.position.x),
                label_box.pos.y,
            )
        else:
            labels.append(
                cdiagram.Box(
                    ref + (child.position.x, child.position.y),
                    (child.size.width, child.size.height),
                    label=child.text,
                    styleoverrides=styleoverrides,
                )
            )

        element = parent
    elif child.type == "junction":
        uuid = uuid.rsplit("_", maxsplit=1)[0]
        pos = cdiagram.Vector2D(child.position.x, child.position.y)
        if self._is_hierarchical(uuid):
            # FIXME should this use `parent` instead?
            target_box = self.diagram[self._diagram.target.uuid]
            assert isinstance(target_box, cdiagram.Box)
            pos += target_box.pos

        element = cdiagram.Circle(
            ref + pos,
            5,
            uuid=child.id,
            styleclass=self.get_styleclass(uuid),
            styleoverrides=styleoverrides,
            context=getattr(child, "context", {}),
        )
        self.diagram.add_element(element)
        self._cache[uuid] = element
    else:
        logger.warning("Received unknown type %s", child.type)
        return

    for i in getattr(child, "children", []):
        if i.type == "edge":
            self._edges.setdefault(i.id, (i, ref, parent))
        elif i.type == "junction":
            self._junctions.setdefault(i.id, (i, ref, parent))
        else:
            self.deserialize_child(i, ref, element)

get_styleclass 🔗

get_styleclass(uuid: str) -> str | None

Return the style-class string from a given _elkjs.ELKOutputChild.

Source code in capellambse_context_diagrams/serializers.py
301
302
303
304
305
306
307
308
309
310
311
312
def get_styleclass(self, uuid: str) -> str | None:
    """Return the style-class string from a given
    [`_elkjs.ELKOutputChild`][capellambse_context_diagrams._elkjs.ELKOutputChild].
    """
    try:
        melodyobj = self._diagram._model.by_uuid(uuid)
    except KeyError:
        if not uuid.startswith("__"):
            return None
        return uuid[2:].split(":", 1)[0]
    else:
        return melodyobj._get_styleclass()

get_styleoverrides 🔗

get_styleoverrides(uuid: str, child: _elkjs.ELKOutputChild, *, derived: bool = False) -> cdiagram.StyleOverrides

Return styling.CSSStyles from a given _elkjs.ELKOutputChild.

Source code in capellambse_context_diagrams/serializers.py
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
def get_styleoverrides(
    self, uuid: str, child: _elkjs.ELKOutputChild, *, derived: bool = False
) -> cdiagram.StyleOverrides:
    """Return
    [`styling.CSSStyles`][capellambse_context_diagrams.styling.CSSStyles]
    from a given
    [`_elkjs.ELKOutputChild`][capellambse_context_diagrams._elkjs.ELKOutputChild].
    """
    style_condition = self._diagram.render_styles.get(child.type)
    styleoverrides: cdiagram.StyleOverrides = {}
    if style_condition is not None:
        if child.type != "junction":
            obj = self._diagram._model.by_uuid(uuid)
        else:
            obj = None

        styleoverrides = style_condition(obj, self) or {}

    if uuid == self._diagram.target.uuid:
        styleoverrides["stroke-width"] = "4"

    if derived:
        styleoverrides["stroke-dasharray"] = "4"

    style: dict[str, t.Any]
    if style := child.style:
        styleoverrides.update(style)
    return styleoverrides

make_diagram 🔗

make_diagram(data: _elkjs.ELKOutputData, **kwargs: t.Any) -> cdiagram.Diagram

Transform a layouted diagram into a diagram.Diagram.

PARAMETER DESCRIPTION
data

The diagram, including layouting information.

TYPE: ELKOutputData

RETURNS DESCRIPTION
diagram

A diagram.Diagram constructed from the input data.

Source code in capellambse_context_diagrams/serializers.py
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
def make_diagram(
    self, data: _elkjs.ELKOutputData, **kwargs: t.Any
) -> cdiagram.Diagram:
    """Transform a layouted diagram into a `diagram.Diagram`.

    Parameters
    ----------
    data
        The diagram, including layouting information.

    Returns
    -------
    diagram
        A [`diagram.Diagram`][capellambse.diagram.Diagram] constructed
        from the input data.
    """
    self.diagram = cdiagram.Diagram(
        self._diagram.name.replace("/", "\\"),
        styleclass=self._diagram.styleclass,
        params=kwargs,
    )
    for child in data.children:
        self.deserialize_child(child, cdiagram.Vector2D(), None)

    for edge, ref, parent in self._edges.values():
        self.deserialize_child(edge, ref, parent)

    for junction, ref, parent in self._junctions.values():
        self.deserialize_child(junction, ref, parent)

    self.diagram.calculate_viewport()
    self.order_children()
    self._edges.clear()
    self._junctions.clear()
    return self.diagram

order_children 🔗

order_children() -> None

Reorder diagram elements such that symbols are drawn last.

Source code in capellambse_context_diagrams/serializers.py
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
def order_children(self) -> None:
    """Reorder diagram elements such that symbols are drawn last."""
    new_diagram = cdiagram.Diagram(
        self.diagram.name,
        styleclass=self.diagram.styleclass,
        params=self.diagram.params,
    )
    draw_last = list[cdiagram.DiagramElement]()
    for element in self.diagram:
        if element.JSON_TYPE in {"symbol", "circle"}:
            draw_last.append(element)
        else:
            new_diagram.add_element(element)

    for element in draw_last:
        new_diagram.add_element(element)

    self.diagram = new_diagram

bring_labels_closer_to_port 🔗

bring_labels_closer_to_port(child: _elkjs.ELKOutputLabel) -> None

Move labels closer to the port.

Source code in capellambse_context_diagrams/serializers.py
404
405
406
407
408
409
410
def bring_labels_closer_to_port(child: _elkjs.ELKOutputLabel) -> None:
    """Move labels closer to the port."""
    if child.position.x > 1:
        child.position.x = -5

    if child.position.x < -11:
        child.position.x += 18

handle_features 🔗

handle_features(child: _elkjs.ELKOutputNode) -> list[str]

Return all consecutive labels (without first) from the child.

Source code in capellambse_context_diagrams/serializers.py
363
364
365
366
367
368
369
370
371
372
373
def handle_features(child: _elkjs.ELKOutputNode) -> list[str]:
    """Return all consecutive labels (without first) from the ``child``."""
    features: list[str] = []
    if len(child.children) <= 1:
        return features

    all_labels = [i for i in child.children if i.type == "label"]
    labels = list(itertools.takewhile(lambda i: i.text, all_labels))
    features = [i.text for i in all_labels[len(labels) + 1 :]]
    child.children = labels  # type: ignore[assignment]
    return features

route_shortest_connection 🔗

route_shortest_connection(source: cdiagram.Box, target: cdiagram.Box) -> list[cdiagram.Vector2D]

Calculate shortest path between boxes with 'Oblique' style.

Calculate the intersection points of the line from source.center to target.center with the bounding boxes of the source and target.

Source code in capellambse_context_diagrams/serializers.py
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
def route_shortest_connection(
    source: cdiagram.Box, target: cdiagram.Box
) -> list[cdiagram.Vector2D]:
    """Calculate shortest path between boxes with 'Oblique' style.

    Calculate the intersection points of the line from source.center to
    target.center with the bounding boxes of the source and target.
    """
    line_start = source.center
    line_end = target.center

    source_intersection = source.vector_snap(
        line_start, source=line_end, style=cdiagram.RoutingStyle.OBLIQUE
    )
    target_intersection = target.vector_snap(
        line_end, source=line_start, style=cdiagram.RoutingStyle.OBLIQUE
    )
    return [source_intersection, target_intersection]